memo_wise 1.1.0 → 1.5.0

data/benchmarks/benchmarks.rb

@@ -2,6 +2,7 @@
 
 require "benchmark/ips"
 
+require "tempfile"
 require "memo_wise"
 
 # Some gems do not yet work in Ruby 3 so we only require them if they're loaded
@@ -49,7 +50,6 @@ end
 # using it to minimize the chance that our benchmarks are affected by ordering.
 # NOTE: Some gems do not yet work in Ruby 3 so we only test with them if they've
 # been `require`d.
-# rubocop:disable Layout/LineLength
 BENCHMARK_GEMS = [
   BenchmarkGem.new(MemoWise, "prepend MemoWise", :memo_wise),
   (BenchmarkGem.new(DDMemoize, "DDMemoize.activate(self)", :memoize) if defined?(DDMemoize)),
@@ -59,17 +59,11 @@ BENCHMARK_GEMS = [
   (BenchmarkGem.new(Memoized, "include Memoized", :memoize) if defined?(Memoized)),
   (BenchmarkGem.new(Memoizer, "include Memoizer", :memoize) if defined?(Memoizer))
 ].compact.shuffle
-# rubocop:enable Layout/LineLength
 
 # Use metaprogramming to ensure that each class is created in exactly the
 # the same way.
 BENCHMARK_GEMS.each do |benchmark_gem|
-  # rubocop:disable Security/Eval
-  eval <<-CLASS, binding, __FILE__, __LINE__ + 1
-    # For these methods, we alternately return truthy and falsey values in
-    # order to benchmark memoization when the result of a method is falsey.
-    #
-    # We do this by checking if the first argument to a method is even.
+  eval <<~HEREDOC, binding, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
     class #{benchmark_gem.klass}Example
       #{benchmark_gem.activation_code}
 
@@ -78,243 +72,173 @@ BENCHMARK_GEMS.each do |benchmark_gem|
       end
       #{benchmark_gem.memoization_method} :no_args
 
-      # For the no_args case, we can't depend on arguments to alternate between
-      # returning truthy and falsey values, so instead make two separate
-      # no_args methods
-      def no_args_falsey
-        nil
-      end
-      #{benchmark_gem.memoization_method} :no_args_falsey
-
       def one_positional_arg(a)
-        100 if a.even?
+        100
       end
       #{benchmark_gem.memoization_method} :one_positional_arg
 
       def positional_args(a, b)
-        100 if a.even?
+        100
       end
       #{benchmark_gem.memoization_method} :positional_args
 
       def one_keyword_arg(a:)
-        100 if a.even?
+        100
       end
       #{benchmark_gem.memoization_method} :one_keyword_arg
 
       def keyword_args(a:, b:)
-        100 if a.even?
+        100
       end
       #{benchmark_gem.memoization_method} :keyword_args
 
       def positional_and_keyword_args(a, b:)
-        100 if a.even?
+        100
       end
       #{benchmark_gem.memoization_method} :positional_and_keyword_args
 
       def positional_and_splat_args(a, *args)
-        100 if a.even?
+        100
       end
       #{benchmark_gem.memoization_method} :positional_and_splat_args
 
       def keyword_and_double_splat_args(a:, **kwargs)
-        100 if a.even?
+        100
       end
       #{benchmark_gem.memoization_method} :keyword_and_double_splat_args
 
       def positional_splat_keyword_and_double_splat_args(a, *args, b:, **kwargs)
-        100 if a.even?
+        100
       end
       #{benchmark_gem.memoization_method} :positional_splat_keyword_and_double_splat_args
     end
-  CLASS
-  # rubocop:enable Security/Eval
+  HEREDOC
 end
 
-# We pre-create argument lists for our memoized methods with arguments, so that
-# our benchmarks are running the exact same inputs for each case.
-N_UNIQUE_ARGUMENTS = 100
-ARGUMENTS = Array.new(N_UNIQUE_ARGUMENTS) { |i| [i, i + 1] }
-
-# We benchmark different cases separately, to ensure that slow performance in
-# one method or code path isn't hidden by fast performance in another.
-
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
+N_RESULT_DECIMAL_DIGITS = 2
 
-    # Run once to memoize the result value, so our benchmark only tests memoized
-    # retrieval time.
+# Each method within these benchmarks is initially run once to memoize the
+# result value, so our benchmark only tests memoized retrieval time.
+benchmark_lambdas = [
+  lambda do |x, instance, benchmark_gem|
     instance.no_args
 
-    x.report("#{benchmark_gem.benchmark_name}: () => truthy") do
+    x.report("#{benchmark_gem.benchmark_name}: ()") do
       instance.no_args
     end
-  end
-
-  x.compare!
-end
-
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
-
-    # Run once to memoize the result value, so our benchmark only tests memoized
-    # retrieval time.
-    instance.no_args_falsey
-
-    x.report("#{benchmark_gem.benchmark_name}: () => falsey") do
-      instance.no_args_falsey
-    end
-  end
-
-  x.compare!
-end
-
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
-
-    # Run once with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
-    ARGUMENTS.each { |a, _| instance.one_positional_arg(a) }
+  end,
+  lambda do |x, instance, benchmark_gem|
+    instance.one_positional_arg(1)
 
     x.report("#{benchmark_gem.benchmark_name}: (a)") do
-      ARGUMENTS.each { |a, _| instance.one_positional_arg(a) }
+      instance.one_positional_arg(1)
     end
-  end
-
-  x.compare!
-end
-
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
-
-    # Run once with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
-    ARGUMENTS.each { |a, b| instance.positional_args(a, b) }
+  end,
+  lambda do |x, instance, benchmark_gem|
+    instance.positional_args(1, 2)
 
     x.report("#{benchmark_gem.benchmark_name}: (a, b)") do
-      ARGUMENTS.each { |a, b| instance.positional_args(a, b) }
+      instance.positional_args(1, 2)
     end
-  end
-
-  x.compare!
-end
-
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
-
-    # Run once with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
-    ARGUMENTS.each { |a, _| instance.one_keyword_arg(a: a) }
+  end,
+  lambda do |x, instance, benchmark_gem|
+    instance.one_keyword_arg(a: 1)
 
     x.report("#{benchmark_gem.benchmark_name}: (a:)") do
-      ARGUMENTS.each { |a, _| instance.one_keyword_arg(a: a) }
+      instance.one_keyword_arg(a: 1)
     end
-  end
-
-  x.compare!
-end
-
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
-
-    # Run once with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
-    ARGUMENTS.each { |a, b| instance.keyword_args(a: a, b: b) }
+  end,
+  lambda do |x, instance, benchmark_gem|
+    instance.keyword_args(a: 1, b: 2)
 
     x.report("#{benchmark_gem.benchmark_name}: (a:, b:)") do
-      ARGUMENTS.each { |a, b| instance.keyword_args(a: a, b: b) }
+      instance.keyword_args(a: 1, b: 2)
     end
-  end
-
-  x.compare!
-end
-
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
-
-    # Run once with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
-    ARGUMENTS.each { |a, b| instance.positional_and_keyword_args(a, b: b) }
+  end,
+  lambda do |x, instance, benchmark_gem|
+    instance.positional_and_keyword_args(1, b: 2)
 
     x.report("#{benchmark_gem.benchmark_name}: (a, b:)") do
-      ARGUMENTS.each { |a, b| instance.positional_and_keyword_args(a, b: b) }
+      instance.positional_and_keyword_args(1, b: 2)
     end
-  end
-
-  x.compare!
-end
-
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
-
-    # Run once with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
-    ARGUMENTS.each { |a, b| instance.positional_and_splat_args(a, b) }
+  end,
+  lambda do |x, instance, benchmark_gem|
+    instance.positional_and_splat_args(1, 2)
 
     x.report("#{benchmark_gem.benchmark_name}: (a, *args)") do
-      ARGUMENTS.each { |a, b| instance.positional_and_splat_args(a, b) }
+      instance.positional_and_splat_args(1, 2)
     end
-  end
-
-  x.compare!
-end
+  end,
+  lambda do |x, instance, benchmark_gem|
+    instance.keyword_and_double_splat_args(a: 1, b: 2)
 
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
-
-    # Run once with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
-    ARGUMENTS.each { |a, b| instance.keyword_and_double_splat_args(a: a, b: b) }
+    x.report("#{benchmark_gem.benchmark_name}: (a:, **kwargs)") do
+      instance.keyword_and_double_splat_args(a: 1, b: 2)
+    end
+  end,
+  lambda do |x, instance, benchmark_gem|
+    instance.positional_splat_keyword_and_double_splat_args(1, 2, b: 3, a: 4)
 
-    x.report(
-      "#{benchmark_gem.benchmark_name}: (a:, **kwargs)"
-    ) do
-      ARGUMENTS.each do |a, b|
-        instance.keyword_and_double_splat_args(a: a, b: b)
-      end
+    x.report("#{benchmark_gem.benchmark_name}: (a, *args, b:, **kwargs)") do
+      instance.positional_splat_keyword_and_double_splat_args(1, 2, b: 3, a: 4)
     end
   end
+]
 
-  x.compare!
-end
+# We benchmark different cases separately, to ensure that slow performance in
+# one method or code path isn't hidden by fast performance in another.
+benchmark_lambdas.map do |benchmark|
+  json_file = Tempfile.new
 
-Benchmark.ips do |x|
-  x.config(suite: suite)
-  BENCHMARK_GEMS.each do |benchmark_gem|
-    instance = Object.const_get("#{benchmark_gem.klass}Example").new
+  Benchmark.ips do |x|
+    x.config(suite: suite)
+    BENCHMARK_GEMS.each do |benchmark_gem|
+      instance = Object.const_get("#{benchmark_gem.klass}Example").new
 
-    # Run once with each set of arguments to memoize the result values, so our
-    # benchmark only tests memoized retrieval time.
-    ARGUMENTS.each do |a, b|
-      instance.positional_splat_keyword_and_double_splat_args(a, b, b: b, a: a)
+      benchmark.call(x, instance, benchmark_gem)
     end
 
-    x.report(
-      "#{benchmark_gem.benchmark_name}: (a, *args, b:, **kwargs)"
-    ) do
-      ARGUMENTS.each do |a, b|
-        instance.
-          positional_splat_keyword_and_double_splat_args(a, b, b: b, a: a)
-      end
-    end
+    x.compare!
+    x.json! json_file.path
   end
 
-  x.compare!
+  JSON.parse(json_file.read)
+end.each_with_index do |benchmark_json, i|
+  # We print a comparison table after we run each benchmark to copy into our
+  # README.md
+
+  # MemoWise will not appear in the comparison table, but we will use it to
+  # compare against other gems' benchmarks
+  memo_wise = benchmark_json.find { _1["name"].include?("MemoWise") }
+  benchmark_json.delete(memo_wise)
+
+  # Sort benchmarks by gem name to alphabetize our final output table.
+  benchmark_json.sort_by! { _1["name"] }
+
+  # Print headers based on the first benchmark_json
+  if i.zero?
+    benchmark_headers = benchmark_json.map do |benchmark_gem|
+      # Gem name is of the form:
+      # "MemoWise (1.1.0): ()"
+      # We use this mapping to get a header of the form
+      # "`MemoWise` (1.1.0)
+      gem_name_parts = benchmark_gem["name"].split
+      "`#{gem_name_parts[0]}` #{gem_name_parts[1][...-1]}"
+    end.join("|")
+    puts "|Method arguments|#{benchmark_headers}|"
+    puts "#{'|--' * (benchmark_json.size + 1)}|"
+  end
+
+  output_str = benchmark_json.map do |bgem|
+    # "%.2f" % 12.345 => "12.34" (instead of "12.35")
+    #   See: https://bugs.ruby-lang.org/issues/12548
+    # 1.00.round(2).to_s => "1.0" (instead of "1.00")
+    #
+    # So to round and format correctly, we first use Float#round and then %
+    "%.#{N_RESULT_DECIMAL_DIGITS}fx" %
+      (memo_wise["central_tendency"] / bgem["central_tendency"]).round(N_RESULT_DECIMAL_DIGITS)
+  end.join("|")
+
+  name = memo_wise["name"].partition(": ").last
+  puts "|`#{name}`#{' (none)' if name == '()'}|#{output_str}|"
 end