1 files changed, 102 insertions, 0 deletions
diff --git a/js/baba-yaga/src/benchmarks/benchmark-test.js b/js/baba-yaga/src/benchmarks/benchmark-test.js
new file mode 100644
index 0000000..c34bffc
--- /dev/null
+++ b/js/baba-yaga/src/benchmarks/benchmark-test.js
@@ -0,0 +1,102 @@
+// benchmark-test.js - Simple benchmark test for our optimizations
+
+import { benchmarkLexers } from './lexer-optimized.js';
+import { benchmarkScopes } from './scope-stack.js';
+import { benchmarkBuiltins } from './builtins-optimized.js';
+import { BabaYagaEngine } from './engine.js';
+import { OptimizedBabaYagaEngine } from './engine-optimized.js';
+import { BabaYagaConfig } from './config.js';
+
+// Test program for benchmarking
+const testProgram = `
+numbers : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+doubled : map (x -> x * 2) numbers;
+filtered : filter (x -> x > 10) doubled;
+sum : reduce (acc x -> acc + x) 0 filtered;
+
+factorial : n ->
+  when n is
+    0 then 1
+    1 then 1
+    _ then n * (factorial (n - 1));
+
+factorials : map factorial [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+result : reduce (acc x -> acc + x) sum factorials;
+io.out result;
+`;
+
+async function runQuickBenchmark() {
+  console.log('🚀 Quick Performance Benchmark\n');
+
+  // Component benchmarks
+  console.log('📊 Component Benchmarks:');
+  
+  console.log('🔤 Lexer:');
+  const lexerResults = await benchmarkLexers(testProgram, 500);
+  
+  console.log('\n📚 Scope Stack:');
+  const scopeResults = await benchmarkScopes(25000);
+  
+  console.log('\n⚡ Built-ins:');
+  const builtinResults = await benchmarkBuiltins(2500);
+  
+  // End-to-end benchmark
+  console.log('\n🏁 End-to-End Benchmark:');
+  
+  // Original engine
+  const originalConfig = new BabaYagaConfig({
+    enableOptimizations: false,
+    enableDebugMode: false
+  });
+  const originalEngine = new BabaYagaEngine(originalConfig);
+  
+  // Warm up
+  for (let i = 0; i < 5; i++) {
+    await originalEngine.execute(testProgram);
+  }
+  
+  const iterations = 500;
+  const originalStart = performance.now();
+  for (let i = 0; i < iterations; i++) {
+    await originalEngine.execute(testProgram);
+  }
+  const originalTime = performance.now() - originalStart;
+  
+  // Optimized engine
+  const optimizedConfig = new BabaYagaConfig({
+    enableOptimizations: true,
+    enableDebugMode: false
+  });
+  const optimizedEngine = new OptimizedBabaYagaEngine(optimizedConfig);
+  
+  // Warm up
+  for (let i = 0; i < 5; i++) {
+    await optimizedEngine.execute(testProgram);
+  }
+  
+  const optimizedStart = performance.now();
+  for (let i = 0; i < iterations; i++) {
+    await optimizedEngine.execute(testProgram);
+  }
+  const optimizedTime = performance.now() - optimizedStart;
+  
+  console.log(`Original engine:  ${originalTime.toFixed(2)}ms (${(originalTime/iterations).toFixed(2)}ms avg)`);
+  console.log(`Optimized engine: ${optimizedTime.toFixed(2)}ms (${(optimizedTime/iterations).toFixed(2)}ms avg)`);
+  console.log(`Overall speedup:  ${(originalTime/optimizedTime).toFixed(2)}x`);
+  
+  // Summary
+  console.log('\n📈 Performance Summary:');
+  console.log(`  Lexer speedup:    ${lexerResults.speedup.toFixed(2)}x`);
+  console.log(`  Scope speedup:    ${scopeResults.speedup.toFixed(2)}x`);
+  console.log(`  Built-in speedup: ${builtinResults.speedup.toFixed(2)}x`);
+  console.log(`  Overall speedup:  ${(originalTime/optimizedTime).toFixed(2)}x`);
+  
+  const optimizedStats = optimizedEngine.getStats();
+  console.log('\n🎯 Optimization Statistics:');
+  console.log(`  Built-in optimization rate: ${(optimizedStats.optimizations.builtinOptimizationRate * 100).toFixed(1)}%`);
+  console.log(`  AST pool hit rate:          ${(optimizedStats.optimizations.astPoolHitRate * 100).toFixed(1)}%`);
+  console.log(`  Total optimizations used:   ${optimizedStats.optimizations.totalOptimizations}`);
+}
+
+// Run the benchmark
+runQuickBenchmark().catch(console.error);