parsanol 3.0.0

data/spec/performance/native_benchmark_spec.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+begin
+  require 'benchmark/ips'
+rescue LoadError
+  return unless defined?(RSpec)
+  RSpec.describe "Native vs Ruby Performance Benchmarks", :performance do
+    it "requires benchmark-ips gem" do
+      skip "benchmark-ips gem not installed"
+    end
+  end
+  return
+end
+require 'parsanol/native'
+
+RSpec.describe "Native vs Ruby Performance Benchmarks", :performance do
+  # Skip if native parser not available
+  before(:all) do
+    skip "Native parser not available" unless Parsanol::Native.available?
+  end
+
+  # Simple calculator parser
+  let(:calc_parser) do
+    Class.new(Parsanol::Parser) do
+      rule(:addition) {
+        multiplication.as(:l) >> (add_op >> multiplication.as(:r)).repeat(1) |
+        multiplication
+      }
+
+      rule(:multiplication) {
+        integer.as(:l) >> (mult_op >> integer.as(:r)).repeat(1) |
+        integer
+      }
+
+      rule(:integer) { digit.repeat(1).as(:i) >> space? }
+      rule(:mult_op) { match['*/'].as(:o) >> space? }
+      rule(:add_op) { match['+-'].as(:o) >> space? }
+      rule(:digit) { match['0-9'] }
+      rule(:space?) { match['\s'].repeat }
+
+      root :addition
+    end
+  end
+
+  # JSON parser
+  let(:json_parser) do
+    Class.new(Parsanol::Parser) do
+      rule(:spaces) { match('\s').repeat(1) }
+      rule(:spaces?) { spaces.maybe }
+      rule(:comma) { spaces? >> str(',') >> spaces? }
+      rule(:digit) { match('[0-9]') }
+
+      rule(:number) {
+        (
+          str('-').maybe >> (
+            str('0') | (match('[1-9]') >> digit.repeat)
+          ) >> (
+            str('.') >> digit.repeat(1)
+          ).maybe >> (
+            match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+          ).maybe
+        ).as(:number)
+      }
+
+      rule(:string) {
+        str('"') >> (
+          str('\\') >> any | str('"').absent? >> any
+        ).repeat.as(:string) >> str('"')
+      }
+
+      rule(:array) {
+        str('[') >> spaces? >>
+        (value >> (comma >> value).repeat).maybe.as(:array) >>
+        spaces? >> str(']')
+      }
+
+      rule(:object) {
+        str('{') >> spaces? >>
+        (entry >> (comma >> entry).repeat).maybe.as(:object) >>
+        spaces? >> str('}')
+      }
+
+      rule(:value) {
+        string | number |
+        object | array |
+        str('true').as(:true) | str('false').as(:false) |
+        str('null').as(:null)
+      }
+
+      rule(:entry) {
+        (
+           string.as(:key) >> spaces? >>
+           str(':') >> spaces? >>
+           value.as(:val)
+        ).as(:entry)
+      }
+
+      rule(:top) { spaces? >> value >> spaces? }
+      root(:top)
+    end
+  end
+
+  # Identifier parser (tests regex patterns)
+  let(:identifier_parser) do
+    Class.new(Parsanol::Parser) do
+      rule(:identifier) { match('[a-zA-Z_]').repeat(1).as(:id) }
+      root :identifier
+    end
+  end
+
+  describe "Simple calculator expressions" do
+    let(:input) { '1 + 2 * 3 + 4 * 5' }
+
+    # NOTE: AST structure differs between Ruby and Native parsers
+    # Ruby flattens sequences, Native returns structured output
+    # Both produce valid parse trees, just structured differently
+    it "native parser successfully parses calculator expressions" do
+      result = Parsanol::Native.parse_parslet_compatible(calc_parser.new, input)
+      expect(result).not_to be_nil
+      # Result can be Array or Hash depending on grammar structure
+      expect(result).to be_a(Array).or be_a(Hash)
+    end
+
+    it "measures speedup" do
+      parser = calc_parser.new
+      grammar = Parsanol::Native.serialize_grammar(parser.root)
+
+      ruby_ips = Benchmark.ips(quiet: true) do |x|
+        x.report('ruby') { parser.parse(input) }
+      end.entries.first.ips
+
+      native_ips = Benchmark.ips(quiet: true) do |x|
+        x.report('native') { Parsanol::Native.parse(grammar, input) }
+      end.entries.first.ips
+
+      speedup = native_ips / ruby_ips
+      puts "Calculator: #{speedup.round(1)}x faster (Ruby: #{ruby_ips.round(0)} ips, Native: #{native_ips.round(0)} ips)"
+
+      # Expect at least 2x speedup for simple grammars
+      expect(speedup).to be > 1.0
+    end
+  end
+
+  describe "JSON parsing" do
+    let(:simple_json) { '{"key": "value", "number": 123}' }
+    let(:nested_json) { '{"a": [1, 2, 3], "b": {"c": "d"}}' }
+
+    # NOTE: AST structure differs between Ruby and Native parsers
+    # Both produce valid parse trees, just structured differently
+    it "native parser successfully parses simple JSON" do
+      result = Parsanol::Native.parse_parslet_compatible(json_parser.new, simple_json)
+      expect(result).not_to be_nil
+    end
+
+    it "measures speedup for simple JSON" do
+      parser = json_parser.new
+      grammar = Parsanol::Native.serialize_grammar(parser.root)
+
+      ruby_ips = Benchmark.ips(quiet: true) do |x|
+        x.report('ruby') { parser.parse(simple_json) }
+      end.entries.first.ips
+
+      native_ips = Benchmark.ips(quiet: true) do |x|
+        x.report('native') { Parsanol::Native.parse(grammar, simple_json) }
+      end.entries.first.ips
+
+      speedup = native_ips / ruby_ips
+      puts "JSON simple: #{speedup.round(1)}x faster (Ruby: #{ruby_ips.round(0)} ips, Native: #{native_ips.round(0)} ips)"
+    end
+  end
+
+  describe "Identifier parsing (regex patterns)" do
+    # Use pattern that matches the entire input
+    let(:identifier_parser) do
+      Class.new(Parsanol::Parser) do
+        rule(:identifier) { match('[a-zA-Z_]').repeat(1).as(:id) }
+        root :identifier
+      end
+    end
+    let(:input) { 'hello_world' }  # No digits, matches [a-zA-Z_]
+
+    # NOTE: Native returns char array, Ruby returns joined string
+    # Both are valid representations
+    it "native parser successfully parses identifier patterns" do
+      result = Parsanol::Native.parse_parslet_compatible(identifier_parser.new, input)
+      expect(result).not_to be_nil
+      expect(result).to have_key(:id)
+    end
+
+    it "measures speedup for identifier parsing" do
+      parser = identifier_parser.new
+      grammar = Parsanol::Native.serialize_grammar(parser.root)
+
+      ruby_ips = Benchmark.ips(quiet: true) do |x|
+        x.report('ruby') { parser.parse(input) }
+      end.entries.first.ips
+
+      native_ips = Benchmark.ips(quiet: true) do |x|
+        x.report('native') { Parsanol::Native.parse(grammar, input) }
+      end.entries.first.ips
+
+      speedup = native_ips / ruby_ips
+      puts "Identifier: #{speedup.round(1)}x faster (Ruby: #{ruby_ips.round(0)} ips, Native: #{native_ips.round(0)} ips)"
+    end
+  end
+
+  describe "Memory allocation comparison" do
+    it "native uses fewer allocations" do
+      input = '1 + 2 * 3'
+      parser = calc_parser.new
+
+      # Measure Ruby allocations
+      GC.start
+      before_ruby = GC.stat(:total_allocated_objects)
+      10.times { parser.parse(input) }
+      ruby_allocs = GC.stat(:total_allocated_objects) - before_ruby
+
+      # Measure Native allocations
+      grammar = Parsanol::Native.serialize_grammar(parser.root)
+      GC.start
+      before_native = GC.stat(:total_allocated_objects)
+      10.times { Parsanol::Native.parse(grammar, input) }
+      native_allocs = GC.stat(:total_allocated_objects) - before_native
+
+      reduction = (1 - native_allocs.to_f / ruby_allocs) * 100
+      puts "Allocations: Ruby=#{ruby_allocs}, Native=#{native_allocs} (#{reduction.round(1)}% reduction)"
+    end
+  end
+end

data/spec/performance/phase5_benchmark.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "parslet"
+require "parslet/native"
+
+puts "=" * 70
+puts "Phase 5 Benchmark: Grammar Hash Caching"
+puts "=" * 70
+
+# First ensure native extension is loaded
+unless Parsanol::Native.available?
+  puts "ERROR: Native extension not available. Run 'rake compile' first."
+  exit 1
+end
+
+# A larger parser to show the impact
+class MediumParser < Parsanol::Parser
+  rule(:space) { match(/\s/).repeat(1) }
+  rule(:space?) { space.maybe }
+
+  rule(:digit) { match(/[0-9]/) }
+  rule(:letter) { match(/[a-zA-Z]/) }
+  rule(:alnum) { match(/[a-zA-Z0-9]/) }
+
+  rule(:integer) { digit.repeat(1) }
+  rule(:float) { digit.repeat(1) >> str(".") >> digit.repeat(1) }
+  rule(:number) { (float | integer).as(:number) }
+
+  rule(:string) { str('"') >> match(/[^"]/).repeat.as(:string) >> str('"') }
+
+  rule(:identifier) { (letter >> alnum.repeat).as(:identifier) }
+
+  rule(:atom) { number | string | identifier }
+
+  rule(:add_op) { str("+") | str("-") }
+  rule(:mul_op) { str("*") | str("/") }
+
+  rule(:mul_expr) { atom >> (space? >> mul_op >> space? >> atom).repeat }
+  rule(:add_expr) { mul_expr >> (space? >> add_op >> space? >> mul_expr).repeat }
+  rule(:expression) { add_expr.as(:expression) }
+
+  rule(:comma) { str(",") >> space? }
+  rule(:arg_list) { expression >> (comma >> expression).repeat }
+  rule(:function_call) { identifier >> str("(") >> space? >> arg_list.as(:args).maybe >> str(")") }
+
+  rule(:statement) { (expression | function_call).as(:statement) >> str(";") }
+  rule(:program) { space? >> statement.repeat.as(:statements) >> space? }
+
+  root(:program)
+end
+
+parser = MediumParser.new
+test_input = 'x = 1 + 2 * 3; y = "hello"; func(x, y, 42);'
+
+puts "\n" + "-" * 70
+puts "Test 1: Cold Cache (first parse)"
+puts "-" * 70
+
+Parsanol::Native.clear_cache
+
+start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+result = Parsanol::Native.parse_parslet_compatible(parser, test_input)
+cold_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
+
+puts "Time: #{cold_time} μs"
+puts "Cache: #{Parsanol::Native.cache_stats}"
+
+puts "\n" + "-" * 70
+puts "Test 2: Warm Cache (grammar hash cached)"
+puts "-" * 70
+
+# The key improvement: object_id cache avoids grammar structure traversal
+times = []
+50.times do
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+  result = Parsanol::Native.parse_parslet_compatible(parser, test_input)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
+  times << elapsed
+end
+
+avg_warm = times.sum / times.length
+puts "Average time: #{avg_warm.round(2)} μs"
+puts "Min: #{times.min.round(2)} μs, Max: #{times.max.round(2)} μs"
+puts "Cache: #{Parsanol::Native.cache_stats}"
+
+puts "\n" + "-" * 70
+puts "Test 3: Repeated parsing with different inputs"
+puts "-" * 70
+
+inputs = [
+  'a = 1;',
+  'b = 2 + 3;',
+  'c = x * y;',
+  'func(a, b, c);',
+  'result = "test";',
+]
+
+Parsanol::Native.clear_cache
+
+# First parse (cold)
+start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+inputs.each { |i| Parsanol::Native.parse_parslet_compatible(parser, i) }
+first_batch = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
+
+# Second batch (warm)
+start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+inputs.each { |i| Parsanol::Native.parse_parslet_compatible(parser, i) }
+second_batch = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
+
+puts "First batch (cold): #{first_batch} μs"
+puts "Second batch (warm): #{second_batch} μs"
+puts "Improvement: #{(first_batch.to_f / second_batch).round(1)}x faster"
+puts "Cache: #{Parsanol::Native.cache_stats}"
+
+puts "\n" + "=" * 70
+puts "SUMMARY"
+puts "=" * 70
+
+speedup = cold_time > 0 && avg_warm > 0 ? (cold_time.to_f / avg_warm).round(0) : 0
+
+puts <<~SUMMARY
+
+  COLD CACHE (first parse):
+    Time: #{cold_time} μs
+
+  WARM CACHE (repeated parsing):
+    Time: #{avg_warm.round(2)} μs
+    Speedup: #{speedup}x faster
+
+  TWO-LEVEL CACHE:
+    Level 1 (object_id → hash): #{Parsanol::Native.cache_stats[:hash_cache_size]} entries
+    Level 2 (hash → json): #{Parsanol::Native.cache_stats[:grammar_cache_size]} entries
+
+  OPTIMIZATION APPLIED:
+    ✓ Two-level grammar caching
+    ✓ Avoids grammar structure traversal on repeated parses
+    ✓ Shares grammar JSON across parser instances with same structure
+
+SUMMARY
+
+puts "=" * 70
+puts "Benchmark complete"
+puts "=" * 70

data/spec/performance/profiling_benchmark.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "parslet"
+require "parslet/native"
+
+puts "=" * 60
+puts "Parsanol Profiling Analysis (Native Parser)"
+puts "=" * 60
+
+# First ensure native extension is loaded
+unless Parsanol::Native.available?
+  puts "ERROR: Native extension not available. Run 'rake compile' first."
+  exit 1
+end
+
+class SimpleParser < Parsanol::Parser
+  rule(:comma) { str(",") >> str(" ").maybe }
+  rule(:word) { match(/[a-z]/).repeat(1) }
+  rule(:alnum) { match(/[a-z0-9]/).repeat(1) }
+
+  rule(:value) { (word | alnum).as(:v) }
+  rule(:list) { value >> (comma >> value).repeat }
+
+  root(:list)
+end
+
+parser = SimpleParser.new
+
+# Test input
+test_input = "one, two, three, four, five, six, seven, eight, nine, ten"
+large_input = (1..100).map { |i| "word" }.join(", ")
+
+# Reset profile
+Parsanol::Native.profile_reset
+
+# Run parsing multiple times using NATIVE parser
+puts "\nRunning 100 native parses..."
+100.times { Parsanol::Native.parse_parslet_compatible(parser, test_input) }
+
+# Get profile
+profile = Parsanol::Native.profile_stats
+
+puts "\n" + "-" * 60
+puts "Profile Results"
+puts "-" * 60
+
+total_us = profile["total_parse_us"].to_i
+if total_us == 0
+  puts "\nWARNING: No timing data collected. Parser may be using Ruby implementation."
+else
+  puts "\nTiming (microseconds):"
+  puts "  Total parse time: #{total_us} us"
+  puts "  Grammar parsing:   #{profile["grammar_parse_us"]} us (#{((profile["grammar_parse_us"].to_f / total_us) * 100).round(1)}%)"
+  puts "  PEG matching:      #{profile["peg_match_us"]} us (#{((profile["peg_match_us"].to_f / total_us) * 100).round(1)}%)"
+  puts "  AST to Ruby:       #{profile["ast_to_ruby_us"]} us (#{((profile["ast_to_ruby_us"].to_f / total_us) * 100).round(1)}%)"
+end
+
+total_cache = profile["cache_hits"].to_i + profile["cache_misses"].to_i
+puts "\nCache Performance:"
+puts "  Hits:   #{profile["cache_hits"]}"
+puts "  Misses: #{profile["cache_misses"]}"
+puts "  Hit rate: #{profile["cache_hit_rate"]}%"
+
+puts "\nMatch Performance:"
+puts "  Lookup matches: #{profile["lookup_matches"]}"
+puts "  Regex matches:  #{profile["regex_matches"]}"
+total_matches = profile["lookup_matches"].to_i + profile["regex_matches"].to_i
+if total_matches > 0
+  lookup_pct = ((profile["lookup_matches"].to_f / total_matches) * 100).round(1)
+  puts "  Fast path: #{lookup_pct}%"
+end
+
+puts "\nAllocation Stats:"
+puts "  AST nodes:        #{profile["ast_nodes"]}"
+puts "  String allocs:    #{profile["string_allocs"]}"
+if profile["ast_nodes"].to_i > 0
+  str_per_node = (profile["string_allocs"].to_f / profile["ast_nodes"].to_i * 100).round(1)
+  puts "  Strings/node:     #{str_per_node}%"
+end
+
+# Performance summary
+puts "\n" + "=" * 60
+puts "Analysis Summary"
+puts "=" * 60
+
+if total_us > 0
+  peg_pct = (profile["peg_match_us"].to_f / total_us * 100).round(1)
+  ruby_pct = (profile["ast_to_ruby_us"].to_f / total_us * 100).round(1)
+
+  puts "\nHot Path Analysis:"
+  if peg_pct > 50
+    puts "  ⚠️  PEG matching is the bottleneck (#{peg_pct}%)"
+    puts "     -> Consider optimizing grammar or using tokens"
+  elsif ruby_pct > 40
+    puts "  ⚠️  AST to Ruby conversion is the bottleneck (#{ruby_pct}%)"
+    puts "     -> Consider batch conversion or fewer allocations"
+  else
+    puts "  ✓  Time is distributed, good balance"
+  end
+
+  if profile["cache_hit_rate"].to_i < 80
+    puts "\n  ⚠️  Cache hit rate is low (#{profile["cache_hit_rate"]}%)"
+    puts "     -> Consider larger cache or different strategy"
+  else
+    puts "\n  ✓  Cache hit rate is good (#{profile["cache_hit_rate"]}%)"
+  end
+else
+  puts "\nNo timing data available for analysis."
+end
+
+# Large input test
+puts "\n" + "-" * 60
+puts "Large Input Test (#{large_input.length} chars)"
+puts "-" * 60
+
+Parsanol::Native.profile_reset
+20.times { Parsanol::Native.parse_parslet_compatible(parser, large_input) }
+profile_large = Parsanol::Native.profile_stats
+
+puts "\nTiming:"
+puts "  Total parse time: #{profile_large["total_parse_us"]} us"
+puts "  PEG matching:      #{profile_large["peg_match_us"]} us"
+puts "  AST to Ruby:       #{profile_large["ast_to_ruby_us"]} us"
+
+puts "\nCache:"
+puts "  Hit rate: #{profile_large["cache_hit_rate"]}%"
+
+puts "\n" + "=" * 60
+puts "Profiling complete"
+puts "=" * 60

data/spec/performance/ruby_improvements_benchmark.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "parslet"
+require "parslet/native"
+
+puts "=" * 60
+puts "Parsanol Ruby Improvements Benchmark"
+puts "=" * 60
+
+# First ensure native extension is loaded
+unless Parsanol::Native.available?
+  puts "ERROR: Native extension not available. Run 'rake compile' first."
+  exit 1
+end
+
+class SimpleParser < Parsanol::Parser
+  rule(:comma) { str(",") >> str(" ").maybe }
+  rule(:word) { match(/[a-z]/).repeat(1) }
+  rule(:alnum) { match(/[a-z0-9]/).repeat(1) }
+
+  rule(:value) { (word | alnum).as(:v) }
+  rule(:list) { value >> (comma >> value).repeat }
+
+  root(:list)
+end
+
+# More complex parser to test caching
+class ExpressionParser < Parsanol::Parser
+  rule(:space) { match(/\s/).repeat(1) }
+  rule(:spaces) { space.maybe }
+
+  rule(:digit) { match(/[0-9]/) }
+  rule(:number) { digit.repeat(1).as(:num) }
+
+  rule(:lparen) { str("(") >> spaces }
+  rule(:rparen) { str(")") >> spaces }
+
+  rule(:plus) { str("+") >> spaces }
+  rule(:minus) { str("-") >> spaces }
+  rule(:times) { str("*") >> spaces }
+  rule(:divide) { str("/") >> spaces }
+
+  rule(:factor) { number | (lparen >> expression >> rparen) }
+  rule(:term) { factor >> ((times | divide) >> factor).repeat }
+  rule(:expression) { term >> ((plus | minus) >> term).repeat }
+
+  root(:expression)
+end
+
+parser = SimpleParser.new
+expr_parser = ExpressionParser.new
+
+# Test inputs
+simple_input = "one, two, three, four, five"
+complex_input = "1 + 2 * 3 - 4 / 5"
+large_input = (1..100).map { |i| "word" }.join(", ")
+
+# Clear cache first
+Parsanol::Native.clear_cache
+
+# ============================================================================
+# Test 1: Simple parser - first parse (cold cache)
+# ============================================================================
+puts "\n" + "-" * 60
+puts "Test 1: Simple Parser (first parse, cold cache)"
+puts "-" * 60
+
+Parsanol::Native.profile_reset
+result1 = Parsanol::Native.parse_parslet_compatible(parser, simple_input)
+profile1 = Parsanol::Native.profile_stats
+
+puts "Result: #{result1.inspect}"
+puts "Time: #{profile1["total_parse_us"]} us"
+
+# ============================================================================
+# Test 2: Simple parser - repeated parses (warm cache)
+# ============================================================================
+puts "\n" + "-" * 60
+puts "Test 2: Simple Parser (100 parses, warm cache)"
+puts "-" * 60
+
+Parsanol::Native.profile_reset
+Parsanol::Native.clear_cache
+
+times = []
+100.times do
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+  Parsanol::Native.parse_parslet_compatible(parser, simple_input)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
+  times << elapsed
+end
+
+avg_time = times.sum / times.length
+profile2 = Parsanol::Native.profile_stats
+
+puts "Average time: #{avg_time} us"
+puts "First parse: #{times.first} us"
+puts "Last parse: #{times.last} us"
+puts "Cache stats: #{Parsanol::Native.cache_stats}"
+
+# ============================================================================
+# Test 3: Complex parser (more grammar atoms)
+# ============================================================================
+puts "\n" + "-" * 60
+puts "Test 3: Expression Parser (100 parses)"
+puts "-" * 60
+
+Parsanol::Native.profile_reset
+Parsanol::Native.clear_cache
+
+times = []
+100.times do
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+  Parsanol::Native.parse_parslet_compatible(expr_parser, complex_input)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
+  times << elapsed
+end
+
+avg_time = times.sum / times.length
+profile3 = Parsanol::Native.profile_stats
+
+puts "Average time: #{avg_time} us"
+puts "First parse: #{times.first} us"
+puts "Last parse: #{times.last} us"
+puts "Cache stats: #{Parsanol::Native.cache_stats}"
+
+# ============================================================================
+# Test 4: Large input
+# ============================================================================
+puts "\n" + "-" * 60
+puts "Test 4: Large Input (#{large_input.length} chars, 20 parses)"
+puts "-" * 60
+
+Parsanol::Native.profile_reset
+Parsanol::Native.clear_cache
+
+times = []
+20.times do
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+  Parsanol::Native.parse_parslet_compatible(parser, large_input)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
+  times << elapsed
+end
+
+avg_time = times.sum / times.length
+profile4 = Parsanol::Native.profile_stats
+
+puts "Average time: #{avg_time} us"
+puts "Cache stats: #{Parsanol::Native.cache_stats}"
+
+# ============================================================================
+# Summary
+# ============================================================================
+puts "\n" + "=" * 60
+puts "Summary"
+puts "=" * 60
+
+puts "\nRuby Optimizations Applied:"
+puts "  - Structural grammar caching (hash-based)"
+puts "  - Frozen string constants"
+puts "  - Optimized AstTransformer"
+puts "  - Direct JSON output from serializer"
+
+puts "\nPerformance Results:"
+puts "  - Grammar caching: Working (hash-based key)"
+puts "  - Cache hits after warmup: #{Parsanol::Native.cache_stats[:size]} grammars cached"
+
+puts "\n" + "=" * 60
+puts "Benchmark complete"
+puts "=" * 60