enclave 0.1.0

data/ext/enclave/mruby/benchmark/vm_optimization_bench.rb

@@ -0,0 +1,513 @@
+# VM Optimization Benchmarks for mruby
+# Usage: ./bin/mruby benchmark/vm_optimization_bench.rb
+#
+# Each benchmark is designed to isolate specific VM behaviors:
+# - Dispatch overhead
+# - Arithmetic operations
+# - Method calls
+# - Array/Hash access
+# - Loop performance
+
+# Benchmark infrastructure
+def measure(name, iterations = 1)
+  # Warm up
+  3.times { yield }
+
+  # Force GC before measurement
+  GC.start
+
+  t0 = Time.now
+  iterations.times { yield }
+  elapsed = Time.now - t0
+
+  puts "#{name}: #{elapsed * 1000 / iterations} ms"
+  elapsed
+end
+
+N = 1_000_000
+M = 100_000
+
+puts "=" * 60
+puts "mruby VM Optimization Benchmarks"
+puts "=" * 60
+puts
+
+#=============================================================================
+# 1. DISPATCH OVERHEAD BENCHMARKS
+# Target: Tail-call threading, computed goto efficiency
+#=============================================================================
+puts "--- Dispatch Overhead ---"
+
+# 1a. Empty loop (pure dispatch cost)
+measure("empty_loop", 10) do
+  i = 0
+  while i < N
+    i += 1
+  end
+end
+
+# 1b. NOP-heavy (many instructions, minimal work)
+measure("nop_sequence", 10) do
+  i = 0
+  while i < M
+    a = 1; b = 2; c = 3; d = 4; e = 5
+    a = 1; b = 2; c = 3; d = 4; e = 5
+    a = 1; b = 2; c = 3; d = 4; e = 5
+    a = 1; b = 2; c = 3; d = 4; e = 5
+    i += 1
+  end
+end
+
+#=============================================================================
+# 2. ARITHMETIC BENCHMARKS
+# Target: Type specialization, register variables, ADDI fusion
+#=============================================================================
+puts
+puts "--- Arithmetic Operations ---"
+
+# 2a. Integer addition (tests OP_ADD fast path)
+measure("int_add", 10) do
+  x = 0
+  i = 0
+  while i < N
+    x = x + 1
+    i += 1
+  end
+  x
+end
+
+# 2b. Integer increment (tests potential OP_INCI fusion)
+measure("int_increment", 10) do
+  x = 0
+  i = 0
+  while i < N
+    x += 1
+    i += 1
+  end
+  x
+end
+
+# 2c. Mixed arithmetic (tests type checking overhead)
+measure("mixed_arith", 10) do
+  x = 0
+  y = 1.5
+  i = 0
+  while i < M
+    x = x + 1
+    y = y + 0.5
+    i += 1
+  end
+  x
+end
+
+# 2d. Comparison in loop (tests OP_LT + JMPNOT fusion potential)
+measure("comparison_loop", 10) do
+  x = 0
+  while x < N
+    x += 1
+  end
+  x
+end
+
+# 2e. Multiple comparisons (branch prediction)
+measure("multi_compare", 10) do
+  i = 0
+  count = 0
+  while i < M
+    count += 1 if i > 100
+    count += 1 if i < 50000
+    count += 1 if i == 25000
+    i += 1
+  end
+  count
+end
+
+#=============================================================================
+# 3. METHOD CALL BENCHMARKS
+# Target: Inline caching, method dispatch optimization
+#=============================================================================
+puts
+puts "--- Method Calls ---"
+
+class BenchClass
+  def empty_method
+  end
+
+  def simple_add(a, b)
+    a + b
+  end
+
+  def self.class_method
+  end
+end
+
+$obj = BenchClass.new
+
+# 3a. Empty method call (pure dispatch overhead)
+measure("empty_method_call", 10) do
+  obj = $obj
+  i = 0
+  while i < M
+    obj.empty_method
+    i += 1
+  end
+end
+
+# 3b. Method with arguments
+measure("method_with_args", 10) do
+  obj = $obj
+  i = 0
+  while i < M
+    obj.simple_add(1, 2)
+    i += 1
+  end
+end
+
+# 3c. Self method call (tests OP_SENDSELF potential)
+class SelfCallBench
+  def run
+    i = 0
+    while i < M
+      helper
+      i += 1
+    end
+  end
+
+  def helper
+  end
+end
+
+measure("self_method_call", 10) do
+  SelfCallBench.new.run
+end
+
+# 3d. Polymorphic call site (tests inline cache invalidation)
+class Duck1
+  def quack; 1; end
+end
+class Duck2
+  def quack; 2; end
+end
+
+$duck1 = Duck1.new
+$duck2 = Duck2.new
+
+measure("polymorphic_call", 10) do
+  d1, d2 = $duck1, $duck2
+  i = 0
+  sum = 0
+  while i < M
+    sum += d1.quack
+    sum += d2.quack
+    i += 1
+  end
+  sum
+end
+
+#=============================================================================
+# 4. ARRAY/HASH BENCHMARKS
+# Target: GETIDX/SETIDX fast path, bounds checking
+#=============================================================================
+puts
+puts "--- Array/Hash Access ---"
+
+$ary = Array.new(1000) { |i| i }
+$hash = {}
+1000.times { |i| $hash[i] = i }
+
+# 4a. Array read (sequential)
+measure("array_read_seq", 10) do
+  ary = $ary
+  i = 0
+  sum = 0
+  while i < M
+    sum += ary[i % 1000]
+    i += 1
+  end
+  sum
+end
+
+# 4b. Array read (constant index - tests constant propagation)
+measure("array_read_const", 10) do
+  ary = $ary
+  i = 0
+  sum = 0
+  while i < M
+    sum += ary[500]
+    i += 1
+  end
+  sum
+end
+
+# 4c. Array write
+measure("array_write", 10) do
+  ary = Array.new(1000, 0)
+  i = 0
+  while i < M
+    ary[i % 1000] = i
+    i += 1
+  end
+end
+
+# 4d. Hash read
+measure("hash_read", 10) do
+  h = $hash
+  i = 0
+  sum = 0
+  while i < M
+    sum += h[i % 1000]
+    i += 1
+  end
+  sum
+end
+
+#=============================================================================
+# 5. LOOP PATTERN BENCHMARKS
+# Target: Loop optimization, branch prediction
+#=============================================================================
+puts
+puts "--- Loop Patterns ---"
+
+# 5a. Simple while loop
+measure("while_loop", 10) do
+  i = 0
+  while i < N
+    i += 1
+  end
+end
+
+# 5b. times iterator (block overhead)
+measure("times_iterator", 10) do
+  sum = 0
+  M.times do |i|
+    sum += i
+  end
+  sum
+end
+
+# 5c. each iterator on array
+$small_ary = (0...1000).to_a
+measure("each_iterator", 10) do
+  ary = $small_ary
+  total = 0
+  1000.times do
+    ary.each { |x| total += x }
+  end
+  total
+end
+
+# 5d. Nested loops
+measure("nested_loop", 10) do
+  sum = 0
+  i = 0
+  while i < 1000
+    j = 0
+    while j < 1000
+      sum += 1
+      j += 1
+    end
+    i += 1
+  end
+  sum
+end
+
+#=============================================================================
+# 6. CONSTANT LOADING BENCHMARKS
+# Target: Constant pre-computation, pool access
+#=============================================================================
+puts
+puts "--- Constant Loading ---"
+
+# 6a. Integer literals (tests LOADI optimization)
+measure("int_literals", 10) do
+  i = 0
+  sum = 0
+  while i < M
+    sum += 1
+    sum += 2
+    sum += 3
+    sum += 42
+    sum += 100
+    i += 1
+  end
+  sum
+end
+
+# 6b. Large integer literals (tests LOADL from pool)
+measure("large_int_literals", 10) do
+  i = 0
+  sum = 0
+  while i < M
+    sum += 1000000
+    sum += 2000000
+    sum += 3000000
+    i += 1
+  end
+  sum
+end
+
+# 6c. Float literals
+measure("float_literals", 10) do
+  i = 0
+  sum = 0.0
+  while i < M
+    sum += 1.5
+    sum += 2.5
+    sum += 3.5
+    i += 1
+  end
+  sum
+end
+
+# 6d. String literals (allocation vs interning)
+measure("string_literals", 5) do
+  i = 0
+  while i < 100000
+    s = "hello"
+    s = "world"
+    s = "test"
+    i += 1
+  end
+end
+
+#=============================================================================
+# 7. BRANCH PREDICTION BENCHMARKS
+# Target: mrb_likely/mrb_unlikely effectiveness
+#=============================================================================
+puts
+puts "--- Branch Prediction ---"
+
+# 7a. Predictable branch (always true)
+measure("predictable_true", 10) do
+  i = 0
+  count = 0
+  while i < N
+    count += 1 if true
+    i += 1
+  end
+  count
+end
+
+# 7b. Predictable branch (always false)
+measure("predictable_false", 10) do
+  i = 0
+  count = 0
+  while i < N
+    count += 1 if false
+    i += 1
+  end
+  count
+end
+
+# 7c. Unpredictable branch (50/50)
+measure("unpredictable_50", 10) do
+  i = 0
+  count = 0
+  while i < M
+    count += 1 if i & 1 == 0
+    i += 1
+  end
+  count
+end
+
+# 7d. Rare branch (error path simulation)
+measure("rare_branch", 10) do
+  i = 0
+  count = 0
+  while i < N
+    count += 1 if i == -1  # Never true
+    i += 1
+  end
+  count
+end
+
+#=============================================================================
+# 8. REGISTER PRESSURE BENCHMARKS
+# Target: Register variable optimization
+#=============================================================================
+puts
+puts "--- Register Pressure ---"
+
+# 8a. Few local variables (should fit in registers)
+measure("few_locals", 10) do
+  i = 0
+  a = 0
+  while i < N
+    a += 1
+    i += 1
+  end
+  a
+end
+
+# 8b. Many local variables (register spilling)
+measure("many_locals", 10) do
+  i = 0
+  a = 0; b = 0; c = 0; d = 0; e = 0
+  f = 0; g = 0; h = 0; j = 0; k = 0
+  l = 0; m = 0; n = 0; o = 0; p = 0
+  while i < M
+    a += 1; b += 1; c += 1; d += 1; e += 1
+    f += 1; g += 1; h += 1; j += 1; k += 1
+    l += 1; m += 1; n += 1; o += 1; p += 1
+    i += 1
+  end
+  a + b + c + d + e + f + g + h + j + k + l + m + n + o + p
+end
+
+#=============================================================================
+# 9. COMPOSITE BENCHMARKS (Real-world-ish)
+#=============================================================================
+puts
+puts "--- Composite Benchmarks ---"
+
+# 9a. Fibonacci (recursion + arithmetic)
+def fib(n)
+  return n if n < 2
+  fib(n - 1) + fib(n - 2)
+end
+
+measure("fibonacci_30", 3) do
+  fib(30)
+end
+
+# 9b. Tak function (heavy recursion)
+def tak(x, y, z)
+  if y < x
+    tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y))
+  else
+    z
+  end
+end
+
+measure("tak_18_12_6", 3) do
+  tak(18, 12, 6)
+end
+
+# 9c. Array manipulation
+measure("array_manipulation", 5) do
+  ary = []
+  10000.times { |i| ary << i }
+  ary.map! { |x| x * 2 }
+  ary.select { |x| x % 3 == 0 }.size
+end
+
+# 9d. String operations
+measure("string_ops", 5) do
+  s = ""
+  10000.times { |i| s = s + i.to_s }
+  s.size
+end
+
+# 9e. Hash operations
+measure("hash_ops", 5) do
+  h = {}
+  50000.times { |i| h[i.to_s] = i }
+  sum = 0
+  h.each { |k, v| sum += v }
+  sum
+end
+
+puts
+puts "=" * 60
+puts "Benchmark complete"
+puts "=" * 60