tests/benchmark: make benchmark cases... bigger

Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: Iabd307b475f6568cff4d1ae6e5ae56ef6a6a6964

tests/benchmark/large.nix

@@ -1,15 +1,50 @@
-# Large :b:oke ---I mean...benchmark, for stress testing
+# Large benchmark for comprehensive stress testing
 let
-  # Generate large list
   range = start: end:
     if start >= end
     then []
     else [start] ++ range (start + 1) end;
 
-  # Deep nesting
+  concat = a: b: a ++ b;
-  deepNest = {a = {b = {c = {d = {e = {f = 42;};};};};};};
+
+  factorial = n:
+    if n <= 1
+    then 1
+    else n * factorial (n - 1);
+
+  # Ackermann function (highly recursive)
+  ackermann = m: n:
+    if m == 0
+    then n + 1
+    else if n == 0
+    then ackermann (m - 1) 1
+    else ackermann (m - 1) (ackermann m (n - 1));
+
+  # Greatest common divisor
+  gcd = a: b:
+    if b == 0
+    then a
+    else gcd b (a - (a / b) * b);
+
+  # Power function
+  pow = base: exp:
+    if exp == 0
+    then 1
+    else if exp == 1
+    then base
+    else base * pow base (exp - 1);
+
+  compose = f: g: x: f (g x);
+  double = x: x * 2;
+  addTen = x: x + 10;
+  square = x: x * x;
+
+  pipeline = compose square (compose double addTen);
+
+  list_100 = range 1 101;
+  list_50 = range 1 51;
+  list_25 = range 1 26;
 
-  # Large attrset
   largeAttrs = {
     a1 = 1;
     a2 = 2;
@@ -31,17 +66,172 @@ let
     b8 = 18;
     b9 = 19;
     b10 = 20;
+    c1 = 21;
+    c2 = 22;
+    c3 = 23;
+    c4 = 24;
+    c5 = 25;
+    c6 = 26;
+    c7 = 27;
+    c8 = 28;
+    c9 = 29;
+    c10 = 30;
+    d1 = 31;
+    d2 = 32;
+    d3 = 33;
+    d4 = 34;
+    d5 = 35;
+    d6 = 36;
+    d7 = 37;
+    d8 = 38;
+    d9 = 39;
+    d10 = 40;
+    e1 = 41;
+    e2 = 42;
+    e3 = 43;
+    e4 = 44;
+    e5 = 45;
+    e6 = 46;
+    e7 = 47;
+    e8 = 48;
+    e9 = 49;
+    e10 = 50;
   };
 
-  # Recursive attrset
+  # Very deep nesting (10 levels)
-  recursive = rec {
+  deepNest = {
-    x = 10;
+    level1 = {
-    y = x * 2;
+      level2 = {
-    z = y + x;
+        level3 = {
-    result = z * 3;
+          level4 = {
+            level5 = {
+              level6 = {
+                level7 = {
+                  level8 = {
+                    level9 = {
+                      level10 = {
+                        treasure = "found";
+                        value = 12345;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    };
   };
+
+  recursiveComplex = rec {
+    base = 10;
+    doubled = base * 2;
+    tripled = base * 3;
+
+    sum = doubled + tripled;
+    product = doubled * tripled;
+
+    x = base * 4;
+    y = x + doubled;
+    z = y * tripled;
+
+    total = sum + product + z;
+    final = total * base;
+  };
+
+  config1 = rec {
+    multiplier = 5;
+    base = 100;
+    result = base * multiplier;
+  };
+
+  config2 = rec {
+    offset = 50;
+    scaled = config1.result + offset;
+    doubled = scaled * 2;
+  };
+
+  config3 = rec {
+    factor = 3;
+    combined = config2.doubled * factor;
+    final = combined + config1.multiplier;
+  };
+
+  baseConfig = {
+    system = {
+      arch = "x86_64";
+      os = "linux";
+    };
+    settings = {
+      enabled = true;
+      level = 5;
+    };
+  };
+
+  overrides = {
+    system = {
+      kernel = "6.1";
+    };
+    settings = {
+      level = 10;
+      extra = "custom";
+    };
+    newSection = {
+      value = 42;
+    };
+  };
+
+  merged =
+    baseConfig
+    // overrides
+    // {
+      system = baseConfig.system // overrides.system;
+      settings =
+        baseConfig.settings
+        // overrides.settings
+        // {
+          combined = baseConfig.settings.level + overrides.settings.level;
+        };
+    };
+
+  fact10 = factorial 10;
+  fact7 = factorial 7;
+  ack_3_3 = ackermann 3 3;
+  gcd_48_18 = gcd 48 18;
+  gcd_100_35 = gcd 100 35;
+  pow_2_10 = pow 2 10;
+  pow_3_5 = pow 3 5;
+
+  pipelineResult = pipeline 5; # ((5 + 10) * 2)^2 = 900
+
+  # List operations
+  concatenated = concat [1 2 3] [4 5 6];
+  multilevel = concat (concat [1] [2 3]) [4 5];
 in {
-  list_100 = range 1 100;
+  # Lists
-  deep = deepNest.a.b.c.d.e.f;
+  inherit list_100 list_50 list_25 concatenated multilevel;
-  inherit largeAttrs recursive;
+
+  # Math results
+  inherit fact10 fact7 ack_3_3 gcd_48_18 gcd_100_35 pow_2_10 pow_3_5 pipelineResult;
+
+  # Data structures
+  inherit largeAttrs merged;
+  deepValue = deepNest.level1.level2.level3.level4.level5.level6.level7.level8.level9.level10.value;
+  deepTreasure = deepNest.level1.level2.level3.level4.level5.level6.level7.level8.level9.level10.treasure;
+
+  # Recursive attrsets
+  recursiveTotal = recursiveComplex.total;
+  recursiveFinal = recursiveComplex.final;
+  computedZ = recursiveComplex.z;
+
+  # Config chain
+  config1Result = config1.result;
+  config2Doubled = config2.doubled;
+  config3Final = config3.final;
+
+  # Merged config
+  mergedCombined = merged.settings.combined;
+  mergedArch = merged.system.arch;
+  mergedKernel = merged.system.kernel;
 }

tests/benchmark/medium.nix

@@ -1,31 +1,75 @@
 let
-  # Recursive fibonacci (not memoized)
+  # Recursive factorial
+  factorial = n:
+    if n <= 1
+    then 1
+    else n * factorial (n - 1);
+
+  # Fibonacci sequence generator
   fib = n:
     if n <= 1
     then n
     else fib (n - 1) + fib (n - 2);
 
-  # List operations
+  # List concatenation test
-  numbers = [1 2 3 4 5 6 7 8 9 10];
+  range = start: end:
-  doubled = builtins.map (x: x * 2) numbers;
+    if start >= end
+    then []
+    else [start] ++ range (start + 1) end;
 
-  # Attrset operations
+  # Curried function application
+  add = x: y: x + y;
+  add5 = add 5;
+
+  # Complex computation
+  compute = x: y: let
+    a = x * 2;
+    b = y + 10;
+    c = a * b;
+  in
+    c / 2;
+
+  # Data structures
+  numbers = range 1 11;
+
+  # Nested attribute operations
   base = {
-    a = 1;
+    config = {
-    b = 2;
+      enable = true;
-    c = 3;
+      value = 42;
+    };
+    data = {
+      items = [1 2 3];
+    };
   };
+
   extended =
     base
     // {
-      d = 4;
+      config =
-      e = 5;
+        base.config
+        // {
+          extra = "test";
+          multiplied = base.config.value * 2;
+        };
+      computed = base.config.value + 100;
     };
 
-  # String operations
+  # Recursive attrset with selections
-  greeting = "Hello";
+  recursive = rec {
-  message = "${greeting}, World!";
+    x = 10;
+    y = x * 2;
+    z = y + x;
+    result = z * 3;
+    final = result + x;
+  };
 in {
-  fibonacci_10 = fib 10;
+  fact5 = factorial 5;
-  inherit doubled extended message;
+  fib7 = fib 7;
+  sum15 = add5 10;
+  computed = compute 10 20;
+  inherit numbers extended;
+  deepValue = extended.config.multiplied;
+  recursiveResult = recursive.result;
+  recursiveFinal = recursive.final;
 }

tests/benchmark/run.sh

@@ -83,7 +83,10 @@ run_benchmark() {
 	src_size=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file" 2>/dev/null)
 	local ir_size
 	ir_size=$(stat -c%s /tmp/bench.nixir 2>/dev/null || stat -f%z /tmp/bench.nixir 2>/dev/null)
-	local ratio=$((ir_size * 100 / src_size))
+	local ratio=0
+	if [[ "$src_size" -gt 0 ]]; then
+		ratio=$((ir_size * 100 / src_size))
+	fi
 	echo -e "  Source size:          ${src_size}B"
 	echo -e "  IR bundle size:       ${ir_size}B (${ratio}% of source)"