truffleruby-3.2.4.fastruby

$ ruby -v code/general/array-argument-vs-splat-arguments.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
Function with single Array argument
                       313.058M i/100ms
Function with splat arguments
                         1.943k i/100ms
Calculating -------------------------------------
Function with single Array argument
                          3.182B (± 2.7%) i/s -     15.966B in   5.021949s
Function with splat arguments
                         21.060k (±11.0%) i/s -    104.922k in   5.068564s

Comparison:
Function with single Array argument: 3181658537.3 i/s
Function with splat arguments:    21060.0 i/s - 151075.75x  (± 0.00) slower

$ ruby -v code/general/assignment.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
 Parallel Assignment   319.718M i/100ms
Sequential Assignment
                       306.725M i/100ms
Calculating -------------------------------------
 Parallel Assignment      3.176B (± 2.3%) i/s -     15.986B in   5.035596s
Sequential Assignment
                          3.164B (± 2.7%) i/s -     15.950B in   5.045659s

Comparison:
 Parallel Assignment: 3176329144.5 i/s
Sequential Assignment: 3163582338.8 i/s - same-ish: difference falls within error

$ ruby -v code/general/attr-accessor-vs-getter-and-setter.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
   getter_and_setter   314.257M i/100ms
       attr_accessor   318.085M i/100ms
Calculating -------------------------------------
   getter_and_setter      3.174B (± 2.1%) i/s -     16.027B in   5.052498s
       attr_accessor      3.172B (± 2.3%) i/s -     15.904B in   5.016879s

Comparison:
   getter_and_setter: 3173621065.1 i/s
       attr_accessor: 3171944091.8 i/s - same-ish: difference falls within error

$ ruby -v code/general/begin-rescue-vs-respond-to.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
      begin...rescue     9.981k i/100ms
         respond_to?   318.098M i/100ms
Calculating -------------------------------------
      begin...rescue    103.016k (± 7.2%) i/s -    519.012k in   5.074905s
         respond_to?      3.193B (± 1.3%) i/s -     16.223B in   5.081444s

Comparison:
         respond_to?: 3193115797.5 i/s
      begin...rescue:   103016.2 i/s - 30996.26x  (± 0.00) slower

$ ruby -v code/general/block-apply-method.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
              normal   321.639M i/100ms
             &method    18.101M i/100ms
Calculating -------------------------------------
              normal      3.163B (± 2.9%) i/s -     16.082B in   5.089084s
             &method    182.059M (± 1.8%) i/s -    923.169M in   5.072523s

Comparison:
              normal: 3162916813.3 i/s
             &method: 182058772.9 i/s - 17.37x  (± 0.00) slower

$ ruby -v code/general/define_method-vs-module-eval.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
module_eval with string
                       132.000  i/100ms
       define_method   233.000  i/100ms
Calculating -------------------------------------
module_eval with string
                          4.454k (±47.4%) i/s -      8.580k in   5.120125s
       define_method     10.830k (±52.7%) i/s -     12.116k in   7.411801s

Comparison:
       define_method:    10830.3 i/s
module_eval with string:     4453.9 i/s - same-ish: difference falls within error

$ ruby -v code/general/format-vs-round-and-to-s.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
         Float#round   262.172k i/100ms
       Kernel#format   188.540k i/100ms
            String#%   189.208k i/100ms
Calculating -------------------------------------
         Float#round      2.775M (± 6.1%) i/s -     13.895M in   5.033665s
       Kernel#format      1.874M (± 2.6%) i/s -      9.427M in   5.032966s
            String#%      1.876M (± 2.8%) i/s -      9.460M in   5.047018s

Comparison:
         Float#round:  2775307.5 i/s
            String#%:  1876049.5 i/s - 1.48x  (± 0.00) slower
       Kernel#format:  1874290.4 i/s - 1.48x  (± 0.00) slower

$ ruby -v code/general/hash-vs-openstruct-on-access.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
                Hash   315.821M i/100ms
          OpenStruct   316.712M i/100ms
Calculating -------------------------------------
                Hash      3.183B (± 2.6%) i/s -     16.107B in   5.063659s
          OpenStruct      3.206B (± 1.6%) i/s -     16.152B in   5.039291s

Comparison:
          OpenStruct: 3206132855.0 i/s
                Hash: 3183111726.0 i/s - same-ish: difference falls within error

$ ruby -v code/general/hash-vs-openstruct.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
                Hash   302.991M i/100ms
          OpenStruct     2.888k i/100ms
Calculating -------------------------------------
                Hash      3.111B (± 6.8%) i/s -     15.756B in   5.092672s
          OpenStruct     30.183k (±24.1%) i/s -    144.400k in   5.019641s

Comparison:
                Hash: 3111293011.2 i/s
          OpenStruct:    30182.7 i/s - 103081.89x  (± 0.00) slower

$ ruby -v code/general/inheritance-check.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
  less than or equal     1.023M i/100ms
  ancestors.include?   218.967k i/100ms
Calculating -------------------------------------
  less than or equal     10.154M (± 7.6%) i/s -     51.148M in   5.071259s
  ancestors.include?      2.267M (± 6.9%) i/s -     11.386M in   5.052900s

Comparison:
  less than or equal: 10153515.7 i/s
  ancestors.include?:  2267426.0 i/s - 4.48x  (± 0.00) slower

$ ruby -v code/general/loop-vs-while-true.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
          While Loop     1.000  i/100ms
         Kernel loop     1.000  i/100ms
Calculating -------------------------------------
          While Loop     32.086  (± 3.1%) i/s -    161.000  in   5.022185s
         Kernel loop     31.971  (± 6.3%) i/s -    160.000  in   5.021644s

Comparison:
          While Loop:       32.1 i/s
         Kernel loop:       32.0 i/s - same-ish: difference falls within error

$ ruby -v code/general/raise-vs-e2mmap.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
$ ruby -v code/array/array-first-vs-index.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
           Array#[0]   317.241M i/100ms
         Array#first   317.752M i/100ms
Calculating -------------------------------------
           Array#[0]      3.195B (± 1.9%) i/s -     16.179B in   5.066552s
         Array#first      3.197B (± 2.2%) i/s -     16.205B in   5.071397s

Comparison:
         Array#first: 3197154562.1 i/s
           Array#[0]: 3194591418.5 i/s - same-ish: difference falls within error

$ ruby -v code/array/array-last-vs-index.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
          Array#[-1]   320.404M i/100ms
          Array#last   312.190M i/100ms
Calculating -------------------------------------
          Array#[-1]      3.171B (± 2.7%) i/s -     16.020B in   5.056849s
          Array#last      3.183B (± 2.7%) i/s -     15.922B in   5.006425s

Comparison:
          Array#last: 3182770617.5 i/s
          Array#[-1]: 3170592114.7 i/s - same-ish: difference falls within error

$ ruby -v code/array/bsearch-vs-find.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
                find     1.000  i/100ms
             bsearch   920.403k i/100ms
Calculating -------------------------------------
                find     13.758  (± 0.0%) i/s -     69.000  in   5.016818s
             bsearch      9.485M (± 2.8%) i/s -     47.861M in   5.050357s

Comparison:
             bsearch:  9484532.8 i/s
                find:       13.8 i/s - 689371.50x  (± 0.00) slower

$ ruby -v code/array/insert-vs-unshift.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
       Array#unshift     1.000  i/100ms
        Array#insert     1.000  i/100ms
Calculating -------------------------------------
       Array#unshift      0.213  (± 0.0%) i/s -      2.000  in   9.394666s
        Array#insert      1.402  (± 0.0%) i/s -      8.000  in   5.706156s

Comparison:
        Array#insert:        1.4 i/s
       Array#unshift:        0.2 i/s - 6.59x  (± 0.00) slower

$ ruby -v code/array/length-vs-size-vs-count.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
        Array#length   321.434M i/100ms
          Array#size   310.141M i/100ms
         Array#count   311.761M i/100ms
Calculating -------------------------------------
        Array#length      3.199B (± 1.6%) i/s -     16.072B in   5.025629s
          Array#size      3.195B (± 2.8%) i/s -     16.127B in   5.052138s
         Array#count      3.178B (± 3.8%) i/s -     15.900B in   5.010875s

Comparison:
        Array#length: 3198826465.5 i/s
          Array#size: 3194852618.6 i/s - same-ish: difference falls within error
         Array#count: 3178451750.5 i/s - same-ish: difference falls within error

$ ruby -v code/array/shuffle-first-vs-sample.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
 Array#shuffle.first    37.180k i/100ms
        Array#sample     3.868M i/100ms
Calculating -------------------------------------
 Array#shuffle.first    371.913k (± 2.4%) i/s -      1.859M in   5.001558s
        Array#sample     38.504M (± 1.9%) i/s -    193.382M in   5.024267s

Comparison:
        Array#sample: 38504242.7 i/s
 Array#shuffle.first:   371912.9 i/s - 103.53x  (± 0.00) slower

$ ruby -v code/date/iso8601-vs-parse.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
        Date.iso8601   885.000  i/100ms
          Date.parse   438.000  i/100ms
Calculating -------------------------------------
        Date.iso8601     16.504k (±35.4%) i/s -     74.340k in   5.014347s
          Date.parse      7.764k (±19.3%) i/s -     37.668k in   5.119980s

Comparison:
        Date.iso8601:    16503.7 i/s
          Date.parse:     7763.8 i/s - 2.13x  (± 0.00) slower

$ ruby -v code/enumerable/each-push-vs-map.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
   Array#each + push   295.556k i/100ms
           Array#map     1.880M i/100ms
Calculating -------------------------------------
   Array#each + push      3.275M (± 4.8%) i/s -     16.551M in   5.066093s
           Array#map     19.492M (± 9.0%) i/s -     97.740M in   5.060260s

Comparison:
           Array#map: 19491805.0 i/s
   Array#each + push:  3275157.3 i/s - 5.95x  (± 0.00) slower

$ ruby -v code/enumerable/each-vs-for-loop.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
            For loop    11.665M i/100ms
               #each    35.611M i/100ms
Calculating -------------------------------------
            For loop    117.534M (± 2.2%) i/s -    594.916M in   5.064416s
               #each    353.703M (± 1.7%) i/s -      1.781B in   5.035656s

Comparison:
               #each: 353703123.4 i/s
            For loop: 117533909.0 i/s - 3.01x  (± 0.00) slower

$ ruby -v code/enumerable/each_with_index-vs-while-loop.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
          While Loop     1.499M i/100ms
     each_with_index     2.787M i/100ms
Calculating -------------------------------------
          While Loop     14.251M (± 2.9%) i/s -     71.951M in   5.053208s
     each_with_index     23.682M (± 3.1%) i/s -    119.829M in   5.065597s

Comparison:
     each_with_index: 23682352.9 i/s
          While Loop: 14250938.3 i/s - 1.66x  (± 0.00) slower

$ ruby -v code/enumerable/inject-symbol-vs-block.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
       inject symbol   309.444k i/100ms
      inject to_proc   312.753k i/100ms
        inject block   309.875k i/100ms
Calculating -------------------------------------
       inject symbol      3.107M (± 2.6%) i/s -     15.782M in   5.082969s
      inject to_proc      3.113M (± 2.2%) i/s -     15.638M in   5.025908s
        inject block      3.120M (± 1.5%) i/s -     15.804M in   5.066172s

Comparison:
        inject block:  3120234.2 i/s
      inject to_proc:  3113059.4 i/s - same-ish: difference falls within error
       inject symbol:  3107123.7 i/s - same-ish: difference falls within error

$ ruby -v code/enumerable/map-flatten-vs-flat_map.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
Array#map.flatten(1)    19.015k i/100ms
   Array#map.flatten    25.981k i/100ms
      Array#flat_map    57.417k i/100ms
Calculating -------------------------------------
Array#map.flatten(1)    264.737k (± 8.7%) i/s -      1.312M in   5.006733s
   Array#map.flatten    267.433k (± 6.7%) i/s -      1.351M in   5.081040s
      Array#flat_map    579.374k (± 6.9%) i/s -      2.928M in   5.090595s

Comparison:
      Array#flat_map:   579374.5 i/s
   Array#map.flatten:   267433.0 i/s - 2.17x  (± 0.00) slower
Array#map.flatten(1):   264736.9 i/s - 2.19x  (± 0.00) slower

$ ruby -v code/enumerable/reverse-each-vs-reverse_each.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
  Array#reverse.each   310.687k i/100ms
  Array#reverse_each     2.364M i/100ms
Calculating -------------------------------------
  Array#reverse.each      3.416M (± 6.2%) i/s -     17.088M in   5.028605s
  Array#reverse_each     23.796M (± 2.7%) i/s -    120.555M in   5.069971s

Comparison:
  Array#reverse_each: 23795717.6 i/s
  Array#reverse.each:  3416044.8 i/s - 6.97x  (± 0.00) slower

$ ruby -v code/enumerable/select-first-vs-detect.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
Enumerable#select.first
                       958.535k i/100ms
   Enumerable#detect     4.644M i/100ms
Calculating -------------------------------------
Enumerable#select.first
                         10.331M (± 8.0%) i/s -    205.126M in  20.020353s
   Enumerable#detect     46.630M (± 2.5%) i/s -    933.467M in  20.032899s

Comparison:
   Enumerable#detect: 46630419.0 i/s
Enumerable#select.first: 10331212.8 i/s - 4.51x  (± 0.00) slower

$ ruby -v code/enumerable/select-last-vs-reverse-detect.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
Enumerable#reverse.detect
                       347.326k i/100ms
Enumerable#select.last
                       515.394k i/100ms
Calculating -------------------------------------
Enumerable#reverse.detect
                          3.513M (± 3.2%) i/s -     17.714M in   5.047155s
Enumerable#select.last
                          5.447M (± 5.7%) i/s -     27.316M in   5.037706s

Comparison:
Enumerable#select.last:  5447388.7 i/s
Enumerable#reverse.detect:  3513380.8 i/s - 1.55x  (± 0.00) slower

$ ruby -v code/enumerable/sort-vs-sort_by.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
Enumerable#sort_by (Symbol#to_proc)
                         4.087k i/100ms
  Enumerable#sort_by     4.302k i/100ms
     Enumerable#sort     5.417k i/100ms
Calculating -------------------------------------
Enumerable#sort_by (Symbol#to_proc)
                         22.754k (±50.6%) i/s -     85.827k in   5.055522s
  Enumerable#sort_by     36.595k (±32.0%) i/s -    146.268k in   5.041972s
     Enumerable#sort     57.168k (± 4.5%) i/s -    287.101k in   5.033490s

Comparison:
     Enumerable#sort:    57168.3 i/s
  Enumerable#sort_by:    36595.0 i/s - 1.56x  (± 0.00) slower
Enumerable#sort_by (Symbol#to_proc):    22753.8 i/s - 2.51x  (± 0.00) slower

$ ruby -v code/enumerable/sort_by-first-vs-min_by.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
   Enumerable#min_by   969.714k i/100ms
Enumerable#sort_by...first
                         8.996k i/100ms
Calculating -------------------------------------
   Enumerable#min_by      9.694M (± 1.9%) i/s -     48.486M in   5.003375s
Enumerable#sort_by...first
                        107.624k (± 6.6%) i/s -    539.760k in   5.048729s

Comparison:
   Enumerable#min_by:  9694161.8 i/s
Enumerable#sort_by...first:   107623.5 i/s - 90.07x  (± 0.00) slower

$ ruby -v code/hash/bracket-vs-dup.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
              Hash[]   652.816k i/100ms
            Hash#dup   745.057k i/100ms
Calculating -------------------------------------
              Hash[]      7.592M (±10.7%) i/s -     37.863M in   5.064281s
            Hash#dup      7.473M (±12.2%) i/s -     37.253M in   5.072899s

Comparison:
              Hash[]:  7592391.6 i/s
            Hash#dup:  7472953.9 i/s - same-ish: difference falls within error

$ ruby -v code/hash/bracket-vs-fetch.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
     Hash#[], symbol   318.985M i/100ms
  Hash#fetch, symbol   316.155M i/100ms
     Hash#[], string    29.272M i/100ms
  Hash#fetch, string    26.882M i/100ms
Calculating -------------------------------------
     Hash#[], symbol      3.210B (± 0.9%) i/s -     16.268B in   5.068414s
  Hash#fetch, symbol      3.213B (± 0.9%) i/s -     16.124B in   5.018264s
     Hash#[], string    292.763M (± 1.4%) i/s -      1.464B in   5.000177s
  Hash#fetch, string    269.151M (± 0.3%) i/s -      1.371B in   5.093791s

Comparison:
  Hash#fetch, symbol: 3213304136.8 i/s
     Hash#[], symbol: 3210007235.4 i/s - same-ish: difference falls within error
     Hash#[], string: 292763233.5 i/s - 10.98x  (± 0.00) slower
  Hash#fetch, string: 269150976.5 i/s - 11.94x  (± 0.00) slower

$ ruby -v code/hash/dig-vs-[]-vs-fetch.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
            Hash#dig    92.019M i/100ms
             Hash#[]    92.115M i/100ms
          Hash#[] ||    92.348M i/100ms
          Hash#[] &&    92.315M i/100ms
          Hash#fetch    92.221M i/100ms
 Hash#fetch fallback    91.610M i/100ms
Calculating -------------------------------------
            Hash#dig    918.264M (± 2.0%) i/s -      4.601B in   5.012707s
             Hash#[]    920.715M (± 1.4%) i/s -      4.606B in   5.003391s
          Hash#[] ||    913.422M (± 2.4%) i/s -      4.617B in   5.058179s
          Hash#[] &&    917.009M (± 1.9%) i/s -      4.616B in   5.035464s
          Hash#fetch    922.113M (± 0.5%) i/s -      4.611B in   5.000636s
 Hash#fetch fallback    922.647M (± 0.3%) i/s -      4.672B in   5.063853s

Comparison:
 Hash#fetch fallback: 922646796.5 i/s
          Hash#fetch: 922112596.1 i/s - same-ish: difference falls within error
             Hash#[]: 920714990.9 i/s - same-ish: difference falls within error
            Hash#dig: 918263989.1 i/s - same-ish: difference falls within error
          Hash#[] &&: 917008680.7 i/s - same-ish: difference falls within error
          Hash#[] ||: 913422221.9 i/s - same-ish: difference falls within error

$ ruby -v code/hash/fetch-vs-fetch-with-block.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
  Hash#fetch + const   318.122M i/100ms
  Hash#fetch + block   310.580M i/100ms
    Hash#fetch + arg   322.196M i/100ms
Calculating -------------------------------------
  Hash#fetch + const      3.178B (± 2.7%) i/s -     15.906B in   5.008346s
  Hash#fetch + block      3.185B (± 2.2%) i/s -     16.150B in   5.073469s
    Hash#fetch + arg      3.183B (± 2.1%) i/s -     16.110B in   5.063527s

Comparison:
  Hash#fetch + block: 3184907167.4 i/s
    Hash#fetch + arg: 3183011768.3 i/s - same-ish: difference falls within error
  Hash#fetch + const: 3178438655.3 i/s - same-ish: difference falls within error

$ ruby -v code/hash/hash-key-sort_by-vs-sort.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
      sort_by + to_h    38.680k i/100ms
         sort + to_h     5.531k i/100ms
Calculating -------------------------------------
      sort_by + to_h    575.068k (± 6.9%) i/s -      2.862M in   5.003468s
         sort + to_h    233.609k (±10.3%) i/s -      1.145M in   5.001017s

Comparison:
      sort_by + to_h:   575068.0 i/s
         sort + to_h:   233609.1 i/s - 2.46x  (± 0.00) slower

$ ruby -v code/hash/keys-each-vs-each_key.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
      Hash#keys.each   191.461k i/100ms
       Hash#each_key   245.285k i/100ms
Calculating -------------------------------------
      Hash#keys.each      2.294M (±10.4%) i/s -     11.296M in   5.042204s
       Hash#each_key      2.450M (± 3.5%) i/s -     12.264M in   5.012774s

Comparison:
       Hash#each_key:  2449717.5 i/s
      Hash#keys.each:  2293516.6 i/s - same-ish: difference falls within error

$ ruby -v code/hash/keys-include-vs-key.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
  Hash#keys.include?   278.000  i/100ms
           Hash#key?     9.771M i/100ms
Calculating -------------------------------------
  Hash#keys.include?      3.145k (±11.7%) i/s -     15.568k in   5.037899s
           Hash#key?     96.790M (± 1.9%) i/s -    488.561M in   5.049652s

Comparison:
           Hash#key?: 96790360.9 i/s
  Hash#keys.include?:     3145.1 i/s - 30775.21x  (± 0.00) slower

$ ruby -v code/hash/merge-bang-vs-[]=.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
         Hash#merge!    41.017k i/100ms
            Hash#[]=    61.287k i/100ms
Calculating -------------------------------------
         Hash#merge!    590.911k (± 9.6%) i/s -      2.953M in   5.053598s
            Hash#[]=    633.632k (± 7.7%) i/s -      3.187M in   5.070454s

Comparison:
            Hash#[]=:   633631.9 i/s
         Hash#merge!:   590910.9 i/s - same-ish: difference falls within error

$ ruby -v code/hash/merge-bang-vs-merge-vs-dup-merge-bang.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
{}#merge!(Hash) do end
                        43.386k i/100ms
      Hash#merge({})    18.495k i/100ms
 Hash#dup#merge!({})    30.779k i/100ms
Calculating -------------------------------------
{}#merge!(Hash) do end
                        393.975k (±10.0%) i/s -      1.952M in   5.009948s
      Hash#merge({})    199.584k (± 9.6%) i/s -    998.730k in   5.060916s
 Hash#dup#merge!({})    321.366k (± 7.3%) i/s -      1.601M in   5.014309s

Comparison:
{}#merge!(Hash) do end:   393975.0 i/s
 Hash#dup#merge!({}):   321365.9 i/s - 1.23x  (± 0.00) slower
      Hash#merge({}):   199583.9 i/s - 1.97x  (± 0.00) slower

$ ruby -v code/hash/merge-vs-double-splat-operator.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
        Hash#**other   315.855M i/100ms
          Hash#merge   315.267M i/100ms
Calculating -------------------------------------
        Hash#**other      3.167B (± 3.2%) i/s -     16.109B in   5.091657s
          Hash#merge      3.195B (± 2.6%) i/s -     16.079B in   5.036866s

Comparison:
          Hash#merge: 3194587239.2 i/s
        Hash#**other: 3167299850.9 i/s - same-ish: difference falls within error

$ ruby -v code/hash/merge-vs-merge-bang.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
          Hash#merge   684.000  i/100ms
         Hash#merge!    55.832k i/100ms
Calculating -------------------------------------
          Hash#merge     11.823k (±14.2%) i/s -     58.140k in   5.037000s
         Hash#merge!    620.336k (± 5.2%) i/s -      3.127M in   5.055079s

Comparison:
         Hash#merge!:   620335.7 i/s
          Hash#merge:    11823.0 i/s - 52.47x  (± 0.00) slower

$ ruby -v code/hash/slice-native-vs-before-native.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
Hash#native-slice        1.747M i/100ms
Array#each               1.454M i/100ms
Array#each_w/_object     1.472M i/100ms
Hash#select-include      2.492M i/100ms
Calculating -------------------------------------
Hash#native-slice        18.813M (± 6.2%) i/s -     94.343M in   5.040497s
Array#each               15.288M (± 5.8%) i/s -     77.059M in   5.063819s
Array#each_w/_object     15.274M (± 7.7%) i/s -     76.551M in   5.056972s
Hash#select-include      24.583M (± 6.2%) i/s -    124.613M in   5.096222s

Comparison:
Hash#select-include : 24583138.3 i/s
Hash#native-slice   : 18812922.2 i/s - 1.31x  (± 0.00) slower
Array#each          : 15287706.9 i/s - 1.61x  (± 0.00) slower
Array#each_w/_object: 15273787.4 i/s - 1.61x  (± 0.00) slower

$ ruby -v code/hash/values-include-vs-value.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
Hash#values.include?   279.000  i/100ms
         Hash#value?   661.000  i/100ms
Calculating -------------------------------------
Hash#values.include?      3.094k (±11.0%) i/s -     15.345k in   5.049204s
         Hash#value?      6.738k (± 0.9%) i/s -     33.711k in   5.003561s

Comparison:
         Hash#value?:     6738.0 i/s
Hash#values.include?:     3094.2 i/s - 2.18x  (± 0.00) slower

$ ruby -v code/method/call-vs-send-vs-method_missing.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
                call   312.962M i/100ms
                send   305.747M i/100ms
      method_missing   320.258M i/100ms
Calculating -------------------------------------
                call      3.173B (± 2.2%) i/s -     15.961B in   5.033001s
                send      3.187B (± 1.8%) i/s -     16.205B in   5.086680s
      method_missing      3.182B (± 3.0%) i/s -     16.013B in   5.037798s

Comparison:
                send: 3186708729.3 i/s
      method_missing: 3181718263.7 i/s - same-ish: difference falls within error
                call: 3172870854.5 i/s - same-ish: difference falls within error

$ ruby -v code/proc-and-block/block-vs-to_proc.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
               Block    45.150k i/100ms
      Symbol#to_proc    71.614k i/100ms
Calculating -------------------------------------
               Block    759.304k (±13.3%) i/s -      3.747M in   5.055748s
      Symbol#to_proc    755.042k (±12.1%) i/s -      3.724M in   5.024584s

Comparison:
               Block:   759304.2 i/s
      Symbol#to_proc:   755042.0 i/s - same-ish: difference falls within error

$ ruby -v code/proc-and-block/proc-call-vs-yield.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
          block.call   319.960M i/100ms
       block + yield   314.981M i/100ms
        unused block   322.742M i/100ms
               yield   322.304M i/100ms
Calculating -------------------------------------
          block.call      3.185B (± 2.8%) i/s -     15.998B in   5.026915s
       block + yield      3.177B (± 2.0%) i/s -     16.064B in   5.057970s
        unused block      3.192B (± 2.4%) i/s -     16.137B in   5.058502s
               yield      3.178B (± 3.4%) i/s -     16.115B in   5.076755s

Comparison:
        unused block: 3192046602.4 i/s
          block.call: 3185294544.9 i/s - same-ish: difference falls within error
               yield: 3178305522.8 i/s - same-ish: difference falls within error
       block + yield: 3177310681.4 i/s - same-ish: difference falls within error

$ ruby -v code/range/cover-vs-include.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
        range#cover?     4.626k i/100ms
      range#include?   165.000  i/100ms
       range#member?   215.000  i/100ms
       plain compare     8.212k i/100ms
Calculating -------------------------------------
        range#cover?     59.315k (±27.7%) i/s -    268.308k in   5.070541s
      range#include?      2.912k (±43.0%) i/s -     11.550k in   5.019602s
       range#member?      2.906k (±39.9%) i/s -     12.040k in   5.021797s
       plain compare     95.836k (±31.8%) i/s -    427.024k in   5.093380s

Comparison:
       plain compare:    95835.8 i/s
        range#cover?:    59315.3 i/s - same-ish: difference falls within error
      range#include?:     2911.8 i/s - 32.91x  (± 0.00) slower
       range#member?:     2906.2 i/s - 32.98x  (± 0.00) slower

$ ruby -v code/string/===-vs-=~-vs-match.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
       String#match?    34.678M i/100ms
           String#=~    32.104M i/100ms
          Regexp#===    30.857M i/100ms
        String#match    31.483M i/100ms
Calculating -------------------------------------
       String#match?    345.965M (± 1.9%) i/s -      1.734B in   5.013682s
           String#=~    320.850M (± 1.3%) i/s -      1.605B in   5.003913s
          Regexp#===    307.662M (± 4.9%) i/s -      1.543B in   5.032335s
        String#match    313.142M (± 2.0%) i/s -      1.574B in   5.029077s

Comparison:
       String#match?: 345964501.5 i/s
           String#=~: 320849574.5 i/s - 1.08x  (± 0.00) slower
        String#match: 313141859.8 i/s - 1.10x  (± 0.00) slower
          Regexp#===: 307662281.7 i/s - 1.12x  (± 0.00) slower

$ ruby -v code/string/casecmp-vs-downcase-==.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
String#downcase + ==     2.707M i/100ms
      String#casecmp     4.881M i/100ms
Calculating -------------------------------------
String#downcase + ==     30.889M (± 8.2%) i/s -    154.292M in   5.040215s
      String#casecmp     48.659M (± 4.6%) i/s -    244.074M in   5.026773s

Comparison:
      String#casecmp: 48658885.1 i/s
String#downcase + ==: 30889340.9 i/s - 1.58x  (± 0.00) slower

$ ruby -v code/string/concatenation.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
            String#+     9.873M i/100ms
       String#concat    10.935M i/100ms
       String#append    10.969M i/100ms
         "foo" "bar"   321.112M i/100ms
  "#{'foo'}#{'bar'}"    11.436M i/100ms
Calculating -------------------------------------
            String#+    112.269M (± 3.8%) i/s -    562.745M in   5.019806s
       String#concat    112.351M (± 3.6%) i/s -    568.634M in   5.067871s
       String#append    111.658M (± 3.8%) i/s -    559.413M in   5.017534s
         "foo" "bar"      3.196B (± 1.6%) i/s -     16.056B in   5.024872s
  "#{'foo'}#{'bar'}"    112.432M (± 3.3%) i/s -    571.824M in   5.091600s

Comparison:
         "foo" "bar": 3196102534.4 i/s
  "#{'foo'}#{'bar'}": 112432105.1 i/s - 28.43x  (± 0.00) slower
       String#concat: 112350651.6 i/s - 28.45x  (± 0.00) slower
            String#+: 112268671.4 i/s - 28.47x  (± 0.00) slower
       String#append: 111658480.2 i/s - 28.62x  (± 0.00) slower

$ ruby -v code/string/dup-vs-unary-plus.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
           String#+@   307.126M i/100ms
          String#dup   308.148M i/100ms
Calculating -------------------------------------
           String#+@      3.152B (± 2.3%) i/s -     15.971B in   5.069773s
          String#dup      3.181B (± 2.3%) i/s -     16.024B in   5.040375s

Comparison:
          String#dup: 3180847516.9 i/s
           String#+@: 3151947855.9 i/s - same-ish: difference falls within error

$ ruby -v code/string/end-string-checking-match-vs-end_with.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
           String#=~     1.369M i/100ms
       String#match?     1.782M i/100ms
    String#end_with?    10.764M i/100ms
Calculating -------------------------------------
           String#=~     14.727M (± 7.0%) i/s -     73.919M in   5.059769s
       String#match?     17.835M (± 0.1%) i/s -     90.892M in   5.096392s
    String#end_with?    106.809M (± 2.4%) i/s -    538.185M in   5.041917s

Comparison:
    String#end_with?: 106809288.6 i/s
       String#match?: 17834694.1 i/s - 5.99x  (± 0.00) slower
           String#=~: 14726862.1 i/s - 7.25x  (± 0.00) slower

$ ruby -v code/string/gsub-vs-sub.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
         String#gsub   783.873k i/100ms
          String#sub   970.962k i/100ms
String#dup["string"]=
                        10.301M i/100ms
Calculating -------------------------------------
         String#gsub      8.321M (± 8.4%) i/s -     41.545M in   5.029308s
          String#sub     10.221M (± 9.8%) i/s -     50.490M in   5.005541s
String#dup["string"]=
                        103.044M (± 4.1%) i/s -    515.051M in   5.008305s

Comparison:
String#dup["string"]=: 103043675.6 i/s
          String#sub: 10221202.6 i/s - 10.08x  (± 0.00) slower
         String#gsub:  8320822.1 i/s - 12.38x  (± 0.00) slower

$ ruby -v code/string/gsub-vs-tr.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
         String#gsub   216.438k i/100ms
           String#tr   162.901k i/100ms
Calculating -------------------------------------
         String#gsub      4.181M (± 9.1%) i/s -     20.778M in   5.016959s
           String#tr      1.665M (± 4.1%) i/s -      8.471M in   5.096885s

Comparison:
         String#gsub:  4181165.4 i/s
           String#tr:  1664933.6 i/s - 2.51x  (± 0.00) slower

$ ruby -v code/string/mutable_vs_immutable_strings.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
      Without Freeze   316.376M i/100ms
         With Freeze   316.391M i/100ms
Calculating -------------------------------------
      Without Freeze      3.176B (± 2.3%) i/s -     16.135B in   5.083627s
         With Freeze      3.141B (± 5.2%) i/s -     15.820B in   5.054758s

Comparison:
      Without Freeze: 3175703124.6 i/s
         With Freeze: 3140716304.8 i/s - same-ish: difference falls within error

$ ruby -v code/string/remove-extra-spaces-or-other-chars.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
 String#gsub/regex+/    12.425k i/100ms
      String#squeeze    83.998k i/100ms
Calculating -------------------------------------
 String#gsub/regex+/    173.019k (± 8.4%) i/s -    857.325k in   5.001326s
      String#squeeze    871.059k (± 5.3%) i/s -      4.368M in   5.029394s

Comparison:
      String#squeeze:   871058.6 i/s
 String#gsub/regex+/:   173018.8 i/s - 5.03x  (± 0.00) slower

$ ruby -v code/string/start-string-checking-match-vs-start_with.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
           String#=~    14.652M i/100ms
       String#match?    13.933M i/100ms
  String#start_with?    15.396M i/100ms
Calculating -------------------------------------
           String#=~    146.916M (± 6.2%) i/s -    732.613M in   5.013031s
       String#match?    139.915M (± 1.4%) i/s -    710.597M in   5.079912s
  String#start_with?    153.375M (± 1.1%) i/s -    769.786M in   5.019556s

Comparison:
  String#start_with?: 153375229.8 i/s
           String#=~: 146915834.0 i/s - same-ish: difference falls within error
       String#match?: 139914927.1 i/s - 1.10x  (± 0.00) slower

$ ruby -v code/string/start_with-vs-substring-==.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
  String#start_with?    88.145k i/100ms
    String#[0, n] ==   147.345k i/100ms
   String#[RANGE] ==   226.829k i/100ms
   String#[0...n] ==   146.296k i/100ms
Calculating -------------------------------------
  String#start_with?      7.034M (± 4.0%) i/s -     35.082M in   4.999687s
    String#[0, n] ==     13.890M (±11.7%) i/s -     68.221M in   5.064579s
   String#[RANGE] ==     15.163M (±13.0%) i/s -     73.493M in   5.004472s
   String#[0...n] ==     13.993M (±12.4%) i/s -     67.735M in   4.999599s

Comparison:
   String#[RANGE] ==: 15163031.1 i/s
   String#[0...n] ==: 13992665.9 i/s - same-ish: difference falls within error
    String#[0, n] ==: 13890349.5 i/s - same-ish: difference falls within error
  String#start_with?:  7034472.1 i/s - 2.16x  (± 0.00) slower

$ ruby -v code/string/sub!-vs-gsub!-vs-[]=.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
  String#['string']=    10.358M i/100ms
 String#sub!'string'     1.021M i/100ms
String#gsub!'string'   862.584k i/100ms
  String#[/regexp/]=    10.026M i/100ms
 String#sub!/regexp/     3.266M i/100ms
String#gsub!/regexp/   959.768k i/100ms
Calculating -------------------------------------
  String#['string']=    103.962M (± 0.3%) i/s -    528.256M in   5.081288s
 String#sub!'string'     11.595M (±10.2%) i/s -     57.173M in   5.001244s
String#gsub!'string'      9.546M (± 7.7%) i/s -     47.442M in   5.008740s
  String#[/regexp/]=    100.554M (± 1.9%) i/s -    511.301M in   5.086952s
 String#sub!/regexp/     33.242M (± 3.6%) i/s -    166.591M in   5.018567s
String#gsub!/regexp/      9.335M (± 9.3%) i/s -     47.029M in   5.091768s

Comparison:
  String#['string']=: 103962091.6 i/s
  String#[/regexp/]=: 100554179.1 i/s - 1.03x  (± 0.00) slower
 String#sub!/regexp/: 33241852.4 i/s - 3.13x  (± 0.00) slower
 String#sub!'string': 11594564.8 i/s - 8.97x  (± 0.00) slower
String#gsub!'string':  9545671.9 i/s - 10.89x  (± 0.00) slower
String#gsub!/regexp/:  9334709.1 i/s - 11.14x  (± 0.00) slower

$ ruby -v code/string/sub-vs-chomp-vs-delete_suffix.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
          String#sub     8.012M i/100ms
        String#chomp     5.868M i/100ms
String#delete_suffix    13.788M i/100ms
Calculating -------------------------------------
          String#sub     84.867M (± 6.9%) i/s -    424.616M in   5.028531s
        String#chomp     58.172M (± 2.6%) i/s -    293.425M in   5.047965s
String#delete_suffix    141.218M (±10.2%) i/s -    703.195M in   5.039094s

Comparison:
String#delete_suffix: 141218138.5 i/s
          String#sub: 84866591.9 i/s - 1.66x  (± 0.00) slower
        String#chomp: 58171839.8 i/s - 2.43x  (± 0.00) slower

$ ruby -v code/string/sub-vs-delete_prefix.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
String#delete_prefix   310.911M i/100ms
          String#sub   127.431M i/100ms
Calculating -------------------------------------
String#delete_prefix      3.179B (± 2.8%) i/s -     16.167B in   5.089592s
          String#sub      1.290B (± 0.5%) i/s -      6.499B in   5.038529s

Comparison:
String#delete_prefix: 3179198630.7 i/s
          String#sub: 1289892892.4 i/s - 2.46x  (± 0.00) slower

$ ruby -v code/string/unpack1-vs-unpack[0].rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
      String#unpack1     1.876M i/100ms
    String#unpack[0]     2.066M i/100ms
Calculating -------------------------------------
      String#unpack1     20.753M (± 3.7%) i/s -    105.076M in   5.070063s
    String#unpack[0]     20.824M (± 2.1%) i/s -    105.363M in   5.061928s

Comparison:
    String#unpack[0]: 20823861.7 i/s
      String#unpack1: 20753256.8 i/s - same-ish: difference falls within error

$ ruby -v code/time/iso8601-vs-parse.rb
truffleruby 24.2.0-dev-8594c3a9, like ruby 3.2.4, GraalVM CE Native [x86_64-linux]
Warming up --------------------------------------
        Time.iso8601    23.275k i/100ms
          Time.parse   303.000  i/100ms
Calculating -------------------------------------
        Time.iso8601    756.818k (±27.4%) i/s -      3.421M in   5.008604s
          Time.parse      6.488k (±10.6%) i/s -     32.118k in   5.031115s

Comparison:
        Time.iso8601:   756817.6 i/s
          Time.parse:     6487.9 i/s - 116.65x  (± 0.00) slower