Merge pull request #2 from lucianghinda/lg/add-tests-for-data-define-positional

Add comparisons for Data.define for creating or accessing attributes

Author: lucianghinda

README.md

@@ -1,19 +1,15 @@
 # Micro Benchmarks on Value Object options in Ruby
 
-A series of micro benchmarks about Data.define vs Struct vs OpenStruct in #Ruby.
-
 This is executed with defaults, no extra settings added.
 
-The tests are focused on using keyword arguments. The results might be different when using positional arguments.
-
 ## How to run the benchmarks
 
 ```bash
 bundle install
 bundle exec ruby <benchmark>
 ```
 
-## Results on my machine
+## Machine use to run the benchmarks
 
 I run the following benchmarks on my machine:
 
@@ -22,6 +18,12 @@ I run the following benchmarks on my machine:
 - Running Mac OS 14.4 (23E214)
 - Ruby 3.3.0
 
+## Comparing Data.define with Struct and OpenStruct
+
+Comparing Data.define with Struct and OpenStruct.
+
+The benchmark is focused on benchmarking the keyword arguments.
+
 ### Creating Values
 
 #### Benchmark with `bmbm`
@@ -128,3 +130,130 @@ Comparison:
               Struct:    28419.6 i/s - same-ish: difference falls within error
           OpenStruct:    13474.6 i/s - 2.13x  slower
 ```
+
+## Comparing Data.define
+
+### Comparing multiple ways to create a new object
+
+#### Benchmark with `bmbm`
+
+This benchmark is run with Ruby default benchmark using `bmbm`
+
+```bash
+Comparing ways to instantiate a Data.define object - Benchmark with bmbm
+Rehearsal --------------------------------------------------------
+Keyword arguments      0.000025   0.000000   0.000025 (  0.000025)
+Positional arguments   0.000058   0.000000   0.000058 (  0.000059)
+Constructor method     0.000053   0.000000   0.000053 (  0.000054)
+Constructor keywords   0.000029   0.000000   0.000029 (  0.000029)
+----------------------------------------------- total: 0.000165sec
+
+                           user     system      total        real
+Keyword arguments      0.000023   0.000001   0.000024 (  0.000023)
+Positional arguments   0.000039   0.000000   0.000039 (  0.000039)
+Constructor method     0.000046   0.000000   0.000046 (  0.000046)
+Constructor keywords   0.000023   0.000000   0.000023 (  0.000023)
+```
+
+#### Benchmarking with `ips`
+
+This benchmark is run with `benchmark-ips` gem.
+
+```bash
+Comparing ways to instantiate a Data.define object - Benchmark with ips
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+   Keyword arguments     5.345k i/100ms
+Positional arguments     2.692k i/100ms
+  Constructor method     2.663k i/100ms
+Constructor keywords     5.354k i/100ms
+Calculating -------------------------------------
+   Keyword arguments     52.390k (± 1.9%) i/s -    261.905k in   5.000971s
+Positional arguments     26.162k (± 1.1%) i/s -    131.908k in   5.042607s
+  Constructor method     26.149k (± 0.8%) i/s -    133.150k in   5.092403s
+Constructor keywords     51.813k (± 1.6%) i/s -    262.346k in   5.064698s
+
+Comparison:
+   Keyword arguments:    52390.1 i/s
+Constructor keywords:    51812.7 i/s - same-ish: difference falls within error
+Positional arguments:    26162.3 i/s - 2.00x  slower
+  Constructor method:    26148.6 i/s - 2.00x  slower
+```
+
+### Benchmarking with `memory`
+
+This benchmark is run with `benchmark-memory` gem.
+
+This test is probably unnecessary cause in the end it creates the same thing.
+
+```bash
+Comparing ways to instantiate a Data.define object - Benchmark with memory
+Calculating -------------------------------------
+   Keyword arguments    36.792k memsize (     0.000  retained)
+                         2.000  objects (     0.000  retained)
+                         0.000  strings (     0.000  retained)
+Positional arguments    36.792k memsize (     0.000  retained)
+                         2.000  objects (     0.000  retained)
+                         0.000  strings (     0.000  retained)
+  Constructor method    36.792k memsize (     0.000  retained)
+                         2.000  objects (     0.000  retained)
+                         0.000  strings (     0.000  retained)
+Constructor keywords    36.792k memsize (     0.000  retained)
+                         2.000  objects (     0.000  retained)
+                         0.000  strings (     0.000  retained)
+
+Comparison:
+   Keyword arguments:      36792 allocated
+Positional arguments:      36792 allocated - same
+  Constructor method:      36792 allocated - same
+Constructor keywords:      36792 allocated - same
+```
+
+### Comparing accessing data from objects created differently
+
+There is no difference in accessing attributes depending on how the object was created.
+
+#### Benchmark with `bmbm`
+
+This benchmark is run with Ruby default benchmark using `bmbm`
+
+```bash
+Comparing accessing data for Data.define object - Benchmark with bmbm
+Rehearsal --------------------------------------------------------
+Keyword arguments      0.000072   0.000002   0.000074 (  0.000074)
+Positional arguments   0.000046   0.000001   0.000047 (  0.000047)
+Constructor method     0.000047   0.000000   0.000047 (  0.000047)
+Constructor keywords   0.000047   0.000001   0.000048 (  0.000048)
+----------------------------------------------- total: 0.000216sec
+
+                           user     system      total        real
+Keyword arguments      0.000048   0.000001   0.000049 (  0.000048)
+Positional arguments   0.000047   0.000000   0.000047 (  0.000047)
+Constructor method     0.000047   0.000000   0.000047 (  0.000048)
+Constructor keywords   0.000047   0.000001   0.000048 (  0.000047)
+```
+
+#### Benchmark with `ips`
+
+This benchmark is run with `benchmark-ips` gem.
+
+```bash
+Comparing accessing data for Data.define object - Benchmark with bmbm
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+   Keyword arguments     2.669k i/100ms
+Positional arguments     2.657k i/100ms
+  Constructor method     2.685k i/100ms
+Constructor keywords     2.690k i/100ms
+Calculating -------------------------------------
+   Keyword arguments     26.925k (± 0.5%) i/s -    136.119k in   5.055637s
+Positional arguments     26.835k (± 0.4%) i/s -    135.507k in   5.049741s
+  Constructor method     26.895k (± 0.3%) i/s -    136.935k in   5.091470s
+Constructor keywords     26.794k (± 0.4%) i/s -    134.500k in   5.019767s
+
+Comparison:
+   Keyword arguments:    26924.8 i/s
+  Constructor method:    26895.3 i/s - same-ish: difference falls within error
+Positional arguments:    26834.9 i/s - same-ish: difference falls within error
+Constructor keywords:    26794.4 i/s - same-ish: difference falls within error
+```

data-define/accessing_attributes/bmbm.rb

@@ -0,0 +1,31 @@
+require 'benchmark'
+
+keys = 1000.times.map { |i| "key#{i}".to_sym }
+values = 1000.times.map { |i| "value#{i}" }
+keys_and_values = Hash[keys.zip(values)]
+
+DataDefine = Data.define(*keys)
+keyword_args = DataDefine.new(**keys_and_values)
+positional_args = DataDefine.new(*values)
+constructor_method = DataDefine[*values]
+constructor_with_keyword_args = DataDefine[**keys_and_values]
+
+puts "Comparing accessing data for Data.define object - Benchmark with bmbm"
+
+Benchmark.bmbm do |x|
+  x.report("Keyword arguments") do
+    keys.each { keyword_args.send(_1) }
+  end
+
+  x.report("Positional arguments") do
+    keys.each { positional_args.send(_1) }
+  end
+
+  x.report("Constructor method") do
+    keys.each { constructor_method.send(_1) }
+  end
+
+  x.report("Constructor keywords") do
+    keys.each { constructor_with_keyword_args.send(_1) }
+  end
+end

data-define/accessing_attributes/ips.rb

@@ -0,0 +1,33 @@
+require 'benchmark/ips'
+
+keys = 1000.times.map { |i| "key#{i}".to_sym }
+values = 1000.times.map { |i| "value#{i}" }
+keys_and_values = Hash[keys.zip(values)]
+
+DataDefine = Data.define(*keys)
+keyword_args = DataDefine.new(**keys_and_values)
+positional_args = DataDefine.new(*values)
+constructor_method = DataDefine[*values]
+constructor_with_keyword_args = DataDefine[**keys_and_values]
+
+puts "Comparing accessing data for Data.define object - Benchmark with bmbm"
+
+Benchmark.ips do |x|
+  x.report("Keyword arguments") do
+    keys.each { keyword_args.send(_1) }
+  end
+
+  x.report("Positional arguments") do
+    keys.each { positional_args.send(_1) }
+  end
+
+  x.report("Constructor method") do
+    keys.each { constructor_method.send(_1) }
+  end
+
+  x.report("Constructor keywords") do
+    keys.each { constructor_with_keyword_args.send(_1) }
+  end
+
+  x.compare!
+end

data-define/creating_values/bmbm.rb

@@ -0,0 +1,27 @@
+require 'benchmark'
+
+keys = 1000.times.map { |i| "key#{i}".to_sym }
+values = 1000.times.map { |i| "value#{i}" }
+keys_and_values = Hash[keys.zip(values)]
+
+DataDefine = Data.define(*keys)
+
+puts "Comparing ways to instantiate a Data.define object - Benchmark with bmbm"
+
+Benchmark.bmbm do |x|
+  x.report("Keyword arguments") do
+    DataDefine.new(**keys_and_values)
+  end
+
+  x.report("Positional arguments") do
+    DataDefine.new(*values)
+  end
+
+  x.report("Constructor method") do
+    DataDefine[*values]
+  end
+
+  x.report("Constructor keywords") do
+    DataDefine[**keys_and_values]
+  end
+end

data-define/creating_values/ips.rb

@@ -0,0 +1,29 @@
+require 'benchmark/ips'
+
+keys = 1000.times.map { |i| "key#{i}".to_sym }
+values = 1000.times.map { |i| "value#{i}" }
+keys_and_values = Hash[keys.zip(values)]
+
+DataDefine = Data.define(*keys)
+
+puts "Comparing ways to instantiate a Data.define object - Benchmark with ips"
+
+Benchmark.ips do |x|
+  x.report("Keyword arguments") do
+    DataDefine.new(**keys_and_values)
+  end
+
+  x.report("Positional arguments") do
+    DataDefine.new(*values)
+  end
+
+  x.report("Constructor method") do
+    DataDefine[*values]
+  end
+
+  x.report("Constructor keywords") do
+    DataDefine[**keys_and_values]
+  end
+
+  x.compare!
+end

data-define/creating_values/memory.rb

@@ -0,0 +1,29 @@
+require 'benchmark/memory'
+
+keys = 1000.times.map { |i| "key#{i}".to_sym }
+values = 1000.times.map { |i| "value#{i}" }
+keys_and_values = Hash[keys.zip(values)]
+
+DataDefine = Data.define(*keys)
+
+puts "Comparing ways to instantiate a Data.define object - Benchmark with memory"
+
+Benchmark.memory do |x|
+  x.report("Keyword arguments") do
+    DataDefine.new(**keys_and_values)
+  end
+
+  x.report("Positional arguments") do
+    DataDefine.new(*values)
+  end
+
+  x.report("Constructor method") do
+    DataDefine[*values]
+  end
+
+  x.report("Constructor keywords") do
+    DataDefine[**keys_and_values]
+  end
+
+  x.compare!
+end