lazy_init 0.1.1 → 0.2.0

data/benchmarks/benchmark.rb

@@ -5,11 +5,10 @@ require 'benchmark/ips'
 require_relative '../lib/lazy_init'
 
 class LazyInitBenchmark
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 
   def initialize
     @results = {}
-    configure_lazy_init
     puts header
   end
 
@@ -17,11 +16,11 @@ class LazyInitBenchmark
     run_basic_patterns
     run_computational_complexity
     run_dependency_injection
-    # run_conditional_loading
     run_class_level_shared
     run_method_memoization
     run_timeout_overhead
     run_exception_handling
+    run_thread_safety
     run_real_world_scenarios
 
     print_summary
@@ -29,17 +28,10 @@ class LazyInitBenchmark
 
   private
 
-  def configure_lazy_init
-    LazyInit.configure do |config|
-      config.track_performance = false
-      config.debug = false
-    end
-  end
-
   def header
     <<~HEADER
       ===================================================================
-      LazyInit Performance Benchmark v#{VERSION}
+      LazyInit Performance Benchmark v#{VERSION} (Fixed Methodology)
       ===================================================================
       Ruby: #{RUBY_VERSION} (#{RUBY_ENGINE})
       Platform: #{RUBY_PLATFORM}
@@ -51,14 +43,22 @@ class LazyInitBenchmark
   def benchmark_comparison(category, test_name, manual_impl, lazy_impl, warmup: true)
     puts "\n--- #{test_name} ---"
 
-    # Warmup if requested
+    # Enhanced warmup for more reliable results
     if warmup
-      manual_impl.call
-      lazy_impl.call
+      puts '  Warming up...'
+      5.times do
+        manual_impl.call
+        lazy_impl.call
+      end
+
+      # Additional warmup for GC stabilization
+      GC.start
+      sleep 0.01
     end
 
-    # Run benchmark
+    # Run benchmark with more iterations for stability
     suite = Benchmark.ips do |x|
+      x.config(time: 5, warmup: 2)
       x.report('Manual', &manual_impl)
       x.report('LazyInit', &lazy_impl)
       x.compare!
@@ -105,14 +105,18 @@ class LazyInitBenchmark
   # ========================================
 
   def run_basic_patterns
-    puts "\n" + '=' * 60
+    puts "\n" + '=' * 30
     puts '1. BASIC LAZY INITIALIZATION PATTERNS'
-    puts '=' * 60
+    puts '=' * 30
 
-    # Hot path performance
+    # Hot path performance - fair comparison after both are initialized
     manual_basic = create_manual_basic
     lazy_basic = create_lazy_basic
 
+    # Pre-initialize both for hot path test
+    manual_basic.expensive_value
+    lazy_basic.expensive_value
+
     benchmark_comparison(
       'Basic Patterns',
       'Hot Path (after initialization)',
@@ -120,7 +124,7 @@ class LazyInitBenchmark
       -> { lazy_basic.expensive_value }
     )
 
-    # Cold start performance
+    # Cold start performance - fresh instances each time
     benchmark_comparison(
       'Basic Patterns',
       'Cold Start (new instances)',
@@ -128,12 +132,21 @@ class LazyInitBenchmark
       -> { create_lazy_basic.expensive_value },
       warmup: false
     )
+
+    # Memory overhead test - check after many instances
+    benchmark_comparison(
+      'Basic Patterns',
+      'Memory Overhead (100 instances)',
+      -> { 100.times { create_manual_basic } },
+      -> { 100.times { create_lazy_basic } },
+      warmup: false
+    )
   end
 
   def run_computational_complexity
-    puts "\n" + '=' * 60
+    puts "\n" + '=' * 30
     puts '2. COMPUTATIONAL COMPLEXITY SCENARIOS'
-    puts '=' * 60
+    puts '=' * 30
 
     # Light computation
     manual_light = create_manual_light
@@ -170,9 +183,9 @@ class LazyInitBenchmark
   end
 
   def run_dependency_injection
-    puts "\n" + '=' * 60
+    puts "\n" + '=' * 30
     puts '3. DEPENDENCY INJECTION PERFORMANCE'
-    puts '=' * 60
+    puts '=' * 30
 
     # Simple dependencies
     manual_deps = create_manual_deps
@@ -195,89 +208,149 @@ class LazyInitBenchmark
       -> { manual_complex.service },
       -> { lazy_complex.service }
     )
-  end
 
-  # def run_conditional_loading
-  #   puts "\n" + "="*60
-  #   puts "4. CONDITIONAL LOADING PERFORMANCE"
-  #   puts "="*60
+    # Mixed access patterns
+    manual_mixed = create_manual_complex_deps
+    lazy_mixed = create_lazy_complex_deps
 
-  #   # Condition true
-  #   manual_true = create_manual_conditional(true)
-  #   lazy_true = create_lazy_conditional(true)
+    benchmark_comparison(
+      'Dependency Injection',
+      'Mixed Access Pattern',
+      lambda {
+        manual_mixed.config
+        manual_mixed.database
+        manual_mixed.service
+      },
+      lambda {
+        lazy_mixed.config
+        lazy_mixed.database
+        lazy_mixed.service
+      }
+    )
+  end
 
-  #   benchmark_comparison(
-  #     "Conditional Loading",
-  #     "Condition True",
-  #     -> { manual_true.feature },
-  #     -> { lazy_true.feature }
-  #   )
+  def run_class_level_shared
+    puts "\n" + '=' * 30
+    puts '4. CLASS-LEVEL SHARED RESOURCES'
+    puts '=' * 30
 
-  #   # Condition false
-  #   manual_false = create_manual_conditional(false)
-  #   lazy_false = create_lazy_conditional(false)
+    # FIXED: Don't pre-initialize class variables
+    benchmark_comparison(
+      'Class-Level Resources',
+      'Shared Resources (Cold)',
+      -> { create_manual_class_var.shared_resource },
+      -> { create_lazy_class_var.shared_resource }
+    )
 
-  #   benchmark_comparison(
-  #     "Conditional Loading",
-  #     "Condition False",
-  #     -> { manual_false.feature },
-  #     -> { lazy_false.feature }
-  #   )
-  # end
+    # Hot path for class variables
+    manual_class_hot = create_manual_class_var
+    lazy_class_hot = create_lazy_class_var
 
-  def run_class_level_shared
-    puts "\n" + '=' * 60
-    puts '5. CLASS-LEVEL SHARED RESOURCES'
-    puts '=' * 60
+    # Initialize both
+    manual_class_hot.shared_resource
+    lazy_class_hot.shared_resource
 
-    manual_class = create_manual_class_var
-    lazy_class = create_lazy_class_var
+    benchmark_comparison(
+      'Class-Level Resources',
+      'Shared Resources (Hot)',
+      -> { manual_class_hot.shared_resource },
+      -> { lazy_class_hot.shared_resource }
+    )
 
+    # Multiple instances accessing same class variable
     benchmark_comparison(
       'Class-Level Resources',
-      'Shared Resources',
-      -> { manual_class.shared_resource },
-      -> { lazy_class.shared_resource }
+      'Multiple Instances Access',
+      lambda {
+        instances = 5.times.map { create_manual_class_var }
+        instances.each(&:shared_resource)
+      },
+      lambda {
+        instances = 5.times.map { create_lazy_class_var }
+        instances.each(&:shared_resource)
+      }
     )
   end
 
   def run_method_memoization
-    puts "\n" + '=' * 60
-    puts '6. METHOD-LOCAL MEMOIZATION'
-    puts '=' * 60
+    puts "\n" + '=' * 30
+    puts '5. METHOD-LOCAL MEMOIZATION'
+    puts '=' * 30
 
+    # FIXED: Fair comparison with same caching behavior
     manual_memo = create_manual_memo
     lazy_memo = create_lazy_memo
 
+    # Test with same key (cache hit scenario)
     benchmark_comparison(
       'Method Memoization',
-      'Hot Path Memoization',
+      'Same Key Cache Hit',
       -> { manual_memo.expensive_calc(100) },
       -> { lazy_memo.expensive_calc(100) }
     )
+
+    # Test with different keys (cache miss scenario)
+    key_counter = 0
+    benchmark_comparison(
+      'Method Memoization',
+      'Different Keys',
+      lambda {
+        key_counter += 1
+        create_manual_memo.expensive_calc(key_counter)
+      },
+      lambda {
+        key_counter += 1
+        create_lazy_memo.expensive_calc(key_counter)
+      },
+      warmup: false
+    )
+
+    # Test cache performance with many keys
+    benchmark_comparison(
+      'Method Memoization',
+      'Many Keys Performance',
+      lambda {
+        memo = create_manual_memo
+        100.times { |i| memo.expensive_calc(i) }
+      },
+      lambda {
+        memo = create_lazy_memo
+        100.times { |i| memo.expensive_calc(i) }
+      }
+    )
   end
 
   def run_timeout_overhead
-    puts "\n" + '=' * 60
-    puts '7. TIMEOUT OVERHEAD'
-    puts '=' * 60
+    puts "\n" + '=' * 30
+    puts '6. TIMEOUT OVERHEAD'
+    puts '=' * 30
 
     no_timeout = create_no_timeout
     with_timeout = create_with_timeout
 
     benchmark_comparison(
       'Timeout Support',
-      'Timeout vs No Timeout',
+      'No Timeout vs With Timeout',
       -> { no_timeout.quick_operation },
       -> { with_timeout.quick_operation }
     )
+
+    # Test timeout configuration overhead
+    benchmark_comparison(
+      'Timeout Support',
+      'Timeout Configuration Cost',
+      -> { create_no_timeout.quick_operation },
+      -> { create_with_timeout.quick_operation },
+      warmup: false
+    )
   end
 
   def run_exception_handling
-    puts "\n" + '=' * 60
-    puts '8. EXCEPTION HANDLING OVERHEAD'
-    puts '=' * 60
+    puts "\n" + '=' * 30
+    puts '7. EXCEPTION HANDLING OVERHEAD'
+    puts '=' * 30
 
+    # FIXED: Same exception handling behavior
     manual_exception = create_manual_exception
     lazy_exception = create_lazy_exception
 
@@ -287,12 +360,134 @@ class LazyInitBenchmark
       -> { manual_exception.failing_method },
       -> { lazy_exception.failing_method }
     )
+
+    # Test exception caching behavior
+    manual_exception_cached = create_manual_exception_cached
+    lazy_exception_cached = create_lazy_exception_cached
+
+    benchmark_comparison(
+      'Exception Handling',
+      'Exception Caching',
+      lambda {
+        begin
+          manual_exception_cached.always_fails
+        rescue StandardError
+          # Exception not cached in manual approach
+        end
+      },
+      lambda {
+        begin
+          lazy_exception_cached.always_fails
+        rescue StandardError
+          # Exception cached in LazyInit
+        end
+      }
+    )
+  end
+
+  def run_thread_safety
+    puts "\n" + '=' * 30
+    puts '8. THREAD SAFETY PERFORMANCE'
+    puts '=' * 30
+
+    # This is where LazyInit should shine - testing concurrent access
+    manual_concurrent = create_manual_concurrent
+    lazy_concurrent = create_lazy_concurrent
+
+    benchmark_comparison(
+      'Thread Safety',
+      'Concurrent Access (10 threads)',
+      lambda {
+        threads = 10.times.map do
+          Thread.new { manual_concurrent.thread_safe_value }
+        end
+        threads.each(&:join)
+      },
+      lambda {
+        threads = 10.times.map do
+          Thread.new { lazy_concurrent.thread_safe_value }
+        end
+        threads.each(&:join)
+      }
+    )
+
+    # Test under high contention
+    benchmark_comparison(
+      'Thread Safety',
+      'High Contention (50 threads)',
+      lambda {
+        instance = create_manual_concurrent
+        threads = 50.times.map do
+          Thread.new { instance.thread_safe_value }
+        end
+        threads.each(&:join)
+      },
+      lambda {
+        instance = create_lazy_concurrent
+        threads = 50.times.map do
+          Thread.new { instance.thread_safe_value }
+        end
+        threads.each(&:join)
+      }
+    )
+
+    # Test reset safety under concurrent access
+    benchmark_comparison(
+      'Thread Safety',
+      'Concurrent Reset Safety',
+      lambda {
+        instance = create_manual_concurrent
+        threads = []
+
+        # Readers
+        10.times do
+          threads << Thread.new do
+            20.times { instance.resettable_value }
+          end
+        end
+
+        # Resetters
+        2.times do
+          threads << Thread.new do
+            5.times do
+              sleep 0.001
+              instance.reset_resettable_value!
+            end
+          end
+        end
+
+        threads.each(&:join)
+      },
+      lambda {
+        instance = create_lazy_concurrent
+        threads = []
+
+        # Readers
+        10.times do
+          threads << Thread.new do
+            20.times { instance.resettable_value }
+          end
+        end
+
+        # Resetters
+        2.times do
+          threads << Thread.new do
+            5.times do
+              sleep 0.001
+              instance.reset_resettable_value!
+            end
+          end
+        end
+
+        threads.each(&:join)
+      }
+    )
   end
 
   def run_real_world_scenarios
-    puts "\n" + '=' * 60
+    puts "\n" + '=' * 30
     puts '9. REAL-WORLD SCENARIOS'
-    puts '=' * 60
+    puts '=' * 30
 
     manual_webapp = create_manual_webapp
     lazy_webapp = create_lazy_webapp
@@ -303,10 +498,44 @@ class LazyInitBenchmark
       -> { manual_webapp.application },
       -> { lazy_webapp.application }
     )
+
+    # Rails-like service pattern
+    benchmark_comparison(
+      'Real-World',
+      'Service Container Pattern',
+      lambda {
+        container = create_manual_service_container
+        container.user_service
+        container.notification_service
+        container.payment_service
+      },
+      lambda {
+        container = create_lazy_service_container
+        container.user_service
+        container.notification_service
+        container.payment_service
+      }
+    )
+
+    # Background job pattern
+    benchmark_comparison(
+      'Real-World',
+      'Background Job Setup',
+      lambda {
+        job = create_manual_background_job
+        job.setup_dependencies
+        job.process_data('test_data')
+      },
+      lambda {
+        job = create_lazy_background_job
+        job.setup_dependencies
+        job.process_data('test_data')
+      }
+    )
   end
 
   # ========================================
-  # FACTORY METHODS
+  # FACTORY METHODS (FIXED)
   # ========================================
 
   def create_manual_basic
@@ -470,38 +699,9 @@ class LazyInitBenchmark
     end.new
   end
 
-  def create_manual_conditional(enabled)
-    Class.new do
-      attr_accessor :feature_enabled
-
-      def initialize(enabled)
-        @feature_enabled = enabled
-      end
-
-      def feature
-        return nil unless feature_enabled
-
-        @feature ||= 'Feature loaded'
-      end
-    end.new(enabled)
-  end
-
-  # def create_lazy_conditional(enabled)
-  #   Class.new do
-  #     extend LazyInit
-  #     attr_accessor :feature_enabled
-
-  #     def initialize(enabled)
-  #       @feature_enabled = enabled
-  #     end
-
-  #     lazy_attr_reader :feature, if_condition: -> { feature_enabled } do
-  #       "Feature loaded"
-  #     end
-  #   end.new(enabled)
-  # end
-
+  # FIXED: Class variable tests without pre-initialization
   def create_manual_class_var
+    # Create fresh class each time to avoid shared state
     Class.new do
       def self.shared_resource
         @@shared_resource ||= "Shared resource #{rand(1000)}"
@@ -514,19 +714,17 @@ class LazyInitBenchmark
   end
 
   def create_lazy_class_var
-    klass = Class.new do
+    # Create fresh class each time without pre-initialization
+    Class.new do
       extend LazyInit
 
       lazy_class_variable :shared_resource do
         "Shared resource #{rand(1000)}"
       end
-    end
-
-    # Initialize the class variable
-    klass.shared_resource
-    klass.new
+    end.new
   end
 
+  # FIXED: Method memoization with fair comparison
   def create_manual_memo
     Class.new do
       def expensive_calc(key)
@@ -540,8 +738,15 @@ class LazyInitBenchmark
     Class.new do
       include LazyInit
 
+      def initialize
+        @memo_cache = {}
+      end
+
       def expensive_calc(key)
-        lazy_once { "computed_#{key}_#{rand(1000)}" }
+        # Fair comparison: cache per key like manual version
+        return @memo_cache[key] if @memo_cache.key?(key)
+
+        @memo_cache[key] = lazy_once { "computed_#{key}_#{rand(1000)}" }
       end
     end.new
   end
@@ -566,6 +771,7 @@ class LazyInitBenchmark
     end.new
   end
 
+  # FIXED: Exception handling with same behavior
   def create_manual_exception
     Class.new do
       def failing_method
@@ -590,6 +796,78 @@ class LazyInitBenchmark
     end.new
   end
 
+  # NEW: Exception caching behavior tests
+  def create_manual_exception_cached
+    Class.new do
+      def always_fails
+        # Manual approach doesn't cache exceptions
+        raise StandardError, 'Always fails'
+      end
+    end.new
+  end
+
+  def create_lazy_exception_cached
+    Class.new do
+      extend LazyInit
+
+      lazy_attr_reader :always_fails do
+        raise StandardError, 'Always fails'
+      end
+    end.new
+  end
+
+  # NEW: Thread safety test implementations
+  def create_manual_concurrent
+    Class.new do
+      def initialize
+        @mutex = Mutex.new
+        @reset_mutex = Mutex.new
+      end
+
+      def thread_safe_value
+        return @thread_safe_value if defined?(@thread_safe_value)
+
+        @mutex.synchronize do
+          return @thread_safe_value if defined?(@thread_safe_value)
+
+          @thread_safe_value = "thread_safe_#{rand(1000)}"
+        end
+      end
+
+      def resettable_value
+        return @resettable_value if defined?(@resettable_value)
+
+        @mutex.synchronize do
+          return @resettable_value if defined?(@resettable_value)
+
+          @resettable_value = "resettable_#{rand(1000)}"
+        end
+      end
+
+      def reset_resettable_value!
+        @reset_mutex.synchronize do
+          @mutex.synchronize do
+            remove_instance_variable(:@resettable_value) if defined?(@resettable_value)
+          end
+        end
+      end
+    end.new
+  end
+
+  def create_lazy_concurrent
+    Class.new do
+      extend LazyInit
+
+      lazy_attr_reader :thread_safe_value do
+        "thread_safe_#{rand(1000)}"
+      end
+
+      lazy_attr_reader :resettable_value do
+        "resettable_#{rand(1000)}"
+      end
+    end.new
+  end
+
   def create_manual_webapp
     Class.new do
       def config
@@ -676,34 +954,155 @@ class LazyInitBenchmark
     end.new
   end
 
+  # NEW: Additional realistic test cases
+  def create_manual_service_container
+    Class.new do
+      def database_config
+        @database_config ||= { url: 'postgresql://localhost/app' }
+      end
+
+      def redis_config
+        @redis_config ||= { url: 'redis://localhost:6379' }
+      end
+
+      def user_service
+        @user_service ||= begin
+          database_config
+          "UserService using #{database_config[:url]}"
+        end
+      end
+
+      def notification_service
+        @notification_service ||= begin
+          redis_config
+          user_service
+          "NotificationService using #{redis_config[:url]} and #{user_service}"
+        end
+      end
+
+      def payment_service
+        @payment_service ||= begin
+          user_service
+          "PaymentService using #{user_service}"
+        end
+      end
+    end.new
+  end
+
+  def create_lazy_service_container
+    Class.new do
+      extend LazyInit
+
+      lazy_attr_reader :database_config do
+        { url: 'postgresql://localhost/app' }
+      end
+
+      lazy_attr_reader :redis_config do
+        { url: 'redis://localhost:6379' }
+      end
+
+      lazy_attr_reader :user_service, depends_on: [:database_config] do
+        "UserService using #{database_config[:url]}"
+      end
+
+      lazy_attr_reader :notification_service, depends_on: %i[redis_config user_service] do
+        "NotificationService using #{redis_config[:url]} and #{user_service}"
+      end
+
+      lazy_attr_reader :payment_service, depends_on: [:user_service] do
+        "PaymentService using #{user_service}"
+      end
+    end.new
+  end
+
+  def create_manual_background_job
+    Class.new do
+      def setup_dependencies
+        processor
+        storage
+        logger
+      end
+
+      def processor
+        @processor ||= 'DataProcessor initialized'
+      end
+
+      def storage
+        @storage ||= begin
+          processor
+          "StorageService using #{processor}"
+        end
+      end
+
+      def logger
+        @logger ||= 'Logger initialized'
+      end
+
+      def process_data(data)
+        setup_dependencies
+        "Processing #{data} with #{processor}, #{storage}, #{logger}"
+      end
+    end.new
+  end
+
+  def create_lazy_background_job
+    Class.new do
+      extend LazyInit
+
+      lazy_attr_reader :processor do
+        'DataProcessor initialized'
+      end
+
+      lazy_attr_reader :storage, depends_on: [:processor] do
+        "StorageService using #{processor}"
+      end
+
+      lazy_attr_reader :logger do
+        'Logger initialized'
+      end
+
+      def setup_dependencies
+        processor
+        storage
+        logger
+      end
+
+      def process_data(data)
+        setup_dependencies
+        "Processing #{data} with #{processor}, #{storage}, #{logger}"
+      end
+    end.new
+  end
+
   # ========================================
-  # RESULTS & SUMMARY
+  # RESULTS & SUMMARY (Enhanced)
   # ========================================
 
   def print_summary
-    puts "\n" + '=' * 80
-    puts 'BENCHMARK SUMMARY'
-    puts '=' * 80
+    puts "\n" + '=' * 30
+    puts 'BENCHMARK SUMMARY (Fixed Methodology)'
+    puts '=' * 30
 
     print_detailed_results
     print_performance_analysis
+    print_thread_safety_analysis
     print_recommendations
   end
 
   def print_detailed_results
     puts "\nDetailed Results:"
-    puts '-' * 50
+    puts '-' * 30
 
     @results.each do |category, tests|
       puts "\n#{category}:"
 
       tests.each do |test_name, data|
-        overhead_str = if data[:overhead_percent] < -50
+        overhead_str = if data[:overhead_percent] < -20
                          "#{(-data[:overhead_percent]).round(1)}% faster"
-                       elsif data[:overhead_percent] > 0
-                         "#{data[:ratio]}x slower"
-                       else
+                       elsif data[:ratio] < 1.2
                          'similar performance'
+                       else
+                         "#{data[:ratio]}x slower"
                        end
 
         puts "  #{test_name}:"
@@ -715,9 +1114,9 @@ class LazyInitBenchmark
   end
 
   def print_performance_analysis
-    puts "\n" + '=' * 50
+    puts "\n" + '=' * 30
     puts 'PERFORMANCE ANALYSIS'
-    puts '=' * 50
+    puts '=' * 30
 
     all_ratios = @results.values.flat_map(&:values).map { |data| data[:ratio] }
     avg_ratio = (all_ratios.sum / all_ratios.size).round(2)
@@ -725,48 +1124,108 @@ class LazyInitBenchmark
     max_ratio = all_ratios.max.round(2)
 
     puts "\nOverall Performance Impact:"
-    puts "  Average slowdown: #{avg_ratio}x"
+    puts "  Average overhead: #{avg_ratio}x"
     puts "  Best case: #{min_ratio}x slower"
     puts "  Worst case: #{max_ratio}x slower"
 
-    # Analyze patterns
+    # Analyze hot path vs cold start
+    basic = @results['Basic Patterns']
+    if basic
+      hot_path = basic['Hot Path (after initialization)']
+      cold_start = basic['Cold Start (new instances)']
+
+      if hot_path && cold_start
+        puts "\nHot Path vs Cold Start:"
+        puts "  Hot path overhead: #{hot_path[:ratio]}x"
+        puts "  Cold start overhead: #{cold_start[:ratio]}x"
+
+        if hot_path[:ratio] < 1.5
+          puts '  ✓ Excellent hot path performance!'
+        elsif cold_start[:ratio] > hot_path[:ratio] * 3
+          puts '  ⚠ Cold start overhead is significant'
+        end
+      end
+    end
+
+    # Analyze computational complexity impact
     computational = @results['Computational Complexity']
-    if computational
-      light_ratio = computational['Lightweight (sum 1..10)'][:ratio]
-      heavy_ratio = computational['Heavy (filter+sqrt 1..10000)'][:ratio]
+    return unless computational
+
+    light_ratio = computational['Lightweight (sum 1..10)']&.[](:ratio)
+    heavy_ratio = computational['Heavy (filter+sqrt 1..10000)']&.[](:ratio)
+
+    return unless light_ratio && heavy_ratio
+
+    puts "\nComputational Complexity Impact:"
+    puts "  Light computation overhead: #{light_ratio}x"
+    puts "  Heavy computation overhead: #{heavy_ratio}x"
+
+    if (light_ratio - heavy_ratio).abs < 0.5
+      puts '  • Overhead is consistent across complexity levels'
+    elsif light_ratio > heavy_ratio
+      puts '  • Better suited for expensive operations'
+    end
+  end
+
+  def print_thread_safety_analysis
+    thread_safety = @results['Thread Safety']
+    return unless thread_safety
+
+    puts "\n" + '=' * 50
+    puts 'THREAD SAFETY ANALYSIS'
+    puts '=' * 50
+
+    concurrent = thread_safety['Concurrent Access (10 threads)']
+    high_contention = thread_safety['High Contention (50 threads)']
+    reset_safety = thread_safety['Concurrent Reset Safety']
 
-      if light_ratio > heavy_ratio * 1.5
-        puts "\n• LazyInit overhead decreases with computation complexity"
-        puts '• Better suited for expensive operations'
+    if concurrent
+      puts "\nConcurrent Access Performance:"
+      puts "  10 threads: #{concurrent[:ratio]}x slower"
+      puts "  50 threads: #{high_contention[:ratio]}x slower" if high_contention
+
+      if concurrent[:ratio] < 2.0
+        puts '  ✓ Good concurrent performance!'
+      elsif concurrent[:ratio] < 5.0
+        puts '  ⚠ Moderate concurrent overhead'
       else
-        puts "\n• LazyInit overhead is consistent across complexity levels"
+        puts '  ❌ High concurrent overhead'
       end
     end
 
-    conditional = @results['Conditional Loading']
-    return unless conditional
-
-    true_ratio = conditional['Condition True'][:ratio]
-    false_ratio = conditional['Condition False'][:ratio]
+    return unless reset_safety
 
-    return unless false_ratio < true_ratio * 0.7
+    puts "\nReset Safety:"
+    puts "  Concurrent reset overhead: #{reset_safety[:ratio]}x"
 
-    puts '• Conditional loading is efficient when conditions are false'
+    if reset_safety[:ratio] < 10.0
+      puts '  ✓ Thread-safe resets are reasonably efficient'
+    else
+      puts '  ⚠ Thread-safe resets have significant overhead'
+    end
   end
 
   def print_recommendations
-    puts "\n" + '=' * 50
+    puts "\n" + '=' * 20
     puts 'RECOMMENDATIONS'
-    puts '=' * 50
+    puts '=' * 20
 
     all_ratios = @results.values.flat_map(&:values).map { |data| data[:ratio] }
     avg_ratio = all_ratios.sum / all_ratios.size
 
+    basic = @results['Basic Patterns']
+    hot_path_ratio = basic&.[]('Hot Path (after initialization)')&.[](:ratio)
+
     puts "\nWhen to use LazyInit:"
-    if avg_ratio > 10
-      puts '• Only for very expensive initialization (>10ms)'
-      puts '• When thread safety is critical'
-      puts '• Complex dependency chains'
+
+    if hot_path_ratio && hot_path_ratio < 1.5
+      puts '✓ Hot path performance is excellent - safe for frequent access'
+      puts '✓ Thread safety benefits outweigh minimal overhead'
+      puts '✓ Recommended for most lazy initialization scenarios'
+    elsif avg_ratio > 10
+      puts '⚠ Only for very expensive initialization (>10ms)'
+      puts '⚠ When thread safety is absolutely critical'
+      puts '⚠ Complex dependency chains only'
     elsif avg_ratio > 5
       puts '• Expensive initialization (>1ms)'
       puts '• Multi-threaded applications'
@@ -777,9 +1236,21 @@ class LazyInitBenchmark
       puts '• Clean dependency management needed'
     end
 
-    puts "\n" + '=' * 80
-    puts 'BENCHMARK COMPLETED'
-    puts '=' * 80
+    puts "\nKey Findings:"
+    puts "• Hot path overhead is minimal (#{hot_path_ratio}x)" if hot_path_ratio && hot_path_ratio < 2.0
+
+    thread_safety = @results['Thread Safety']
+    if thread_safety
+      concurrent_ratio = thread_safety['Concurrent Access (10 threads)']&.[](:ratio)
+      puts '• Good performance under concurrent access' if concurrent_ratio && concurrent_ratio < 3.0
+    end
+
+    puts '• Trade-off: initialization cost vs runtime safety'
+    puts '• Consider cold start impact for short-lived processes'
+
+    puts "\n" + '=' * 50
+    puts 'BENCHMARK COMPLETED (Fixed Methodology)'
+    puts '=' * 50
   end
 end
 
@@ -790,7 +1261,7 @@ if __FILE__ == $0
     benchmark.run_all
   rescue StandardError => e
     puts "Benchmark failed: #{e.message}"
-    puts e.backtrace.first(5)
+    puts e.backtrace.first(10)
     exit 1
   end
 end