1 files changed, 206 insertions, 0 deletions
diff --git a/internal/cpu/algorithms.go b/internal/cpu/algorithms.go
new file mode 100644
index 0000000..2dd3fe4
--- /dev/null
+++ b/internal/cpu/algorithms.go
@@ -0,0 +1,206 @@
+// Package cpu provides CPU stress testing with multiple algorithms and chaos modes.
+package cpu
+
+import (
+	"context"
+	"crypto/md5"
+	"crypto/sha256"
+	"math"
+	"sort"
+)
+
+// algorithms.go implements all CPU stress algorithms (prime, matrix, hash, etc.).
+
+func (s *Stresser) stressPrime(ctx context.Context, n int) {
+	count := 0
+	for i := 2; count < n; i++ {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		if isPrime(i) {
+			count++
+		}
+	}
+}
+
+func isPrime(n int) bool {
+	if n < 2 {
+		return false
+	}
+	for i := 2; i*i <= n; i++ {
+		if n%i == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func (s *Stresser) stressMatrix(ctx context.Context, size int) {
+	if size < 10 {
+		size = 10
+	}
+	if size > 200 {
+		size = 200
+	}
+
+	a := make([][]float64, size)
+	b := make([][]float64, size)
+	for i := range a {
+		a[i] = make([]float64, size)
+		b[i] = make([]float64, size)
+		for j := range a[i] {
+			a[i][j] = float64(i+j) * 0.5
+			b[i][j] = float64(i*j) * 0.3
+		}
+	}
+
+	c := make([][]float64, size)
+	for i := range c {
+		c[i] = make([]float64, size)
+		for j := range c[i] {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+			}
+			sum := 0.0
+			for k := 0; k < size; k++ {
+				sum += a[i][k] * b[k][j]
+			}
+			c[i][j] = sum
+		}
+	}
+}
+
+func (s *Stresser) stressHash(ctx context.Context, iterations int) {
+	data := make([]byte, 1024)
+	for i := range data {
+		data[i] = byte(i % 256)
+	}
+
+	for i := 0; i < iterations; i++ {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		sha256.Sum256(data)
+		md5.Sum(data)
+	}
+}
+
+func (s *Stresser) stressBitwise(ctx context.Context, iterations int) {
+	var result uint64 = 0
+	for i := 0; i < iterations*100; i++ {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		result ^= uint64(i) << (i % 64)
+		result |= result >> 3
+		result &= result << 7
+		result += result ^ 0x5555555555555555
+		result = (result << 13) | (result >> 51)
+	}
+	_ = result
+}
+
+func (s *Stresser) stressFloat(ctx context.Context, iterations int) {
+	x := 1.0
+	for i := 0; i < iterations*10; i++ {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		x = math.Sin(x) + math.Cos(x*0.5)
+		x = math.Sqrt(math.Abs(x)) + math.Exp(x*0.01)
+		x = math.Atan(x) + math.Log(math.Abs(x)+1)
+	}
+	_ = x
+}
+
+func (s *Stresser) stressRecurse(ctx context.Context, n int) {
+	if n > 35 {
+		n = 35
+	}
+	_ = fibonacci(n)
+}
+
+func fibonacci(n int) int {
+	if n <= 1 {
+		return n
+	}
+	return fibonacci(n-1) + fibonacci(n-2)
+}
+
+func (s *Stresser) stressCompress(ctx context.Context, iterations int) {
+	data := make([]byte, 1024)
+	for i := range data {
+		data[i] = byte((i * 7) % 256)
+	}
+
+	for i := 0; i < iterations; i++ {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		hash := md5.Sum(data)
+		data = append(data, hash[:]...)
+		if len(data) > 10240 {
+			data = data[:1024]
+		}
+	}
+}
+
+func (s *Stresser) stressEncrypt(ctx context.Context, iterations int) {
+	key := make([]byte, 32)
+	data := make([]byte, 256)
+	for i := range data {
+		data[i] = byte(i % 256)
+	}
+
+	for i := 0; i < iterations; i++ {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		hash := sha256.Sum256(append(key, data...))
+		data = hash[:]
+	}
+}
+
+func (s *Stresser) stressSort(ctx context.Context, size int) {
+	if size < 100 {
+		size = 100
+	}
+	if size > 10000 {
+		size = 10000
+	}
+
+	data := make([]int, size)
+	for i := range data {
+		data[i] = s.rand.Intn(1000000)
+	}
+
+	sort.Ints(data)
+}
+
+func (s *Stresser) stressBusy(ctx context.Context, iterations int) {
+	var sum int64 = 0
+	for i := 0; i < iterations*1000; i++ {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		sum += int64(i * i)
+		sum = sum % 1000000007
+	}
+	_ = sum
+}