iframe-proxy

marcandre · 2020-12-23T21:28:48Z

This avoids recursive checks when the hash method of an object isn't specialized.

marcandre · 2020-12-23T21:31:01Z

This speeds up hash[Object.new] or hash[Module] by a factor of 3x or 4x (but still slower than if hash uses compare_by_identity)...
It also speeds up lookup of structures (Array/Hash/Struct/...) with contents that are themselves objects without a specialized #hash function.

Benchmark results and code here

$ ruby -v bench.rb
ruby 3.0.0dev (2020-12-22T17:37:59Z master 487355873a) [x86_64-darwin18]
       user     system      total        real
empty loop        0.004466   0.000024   0.004490 (  0.004503)
identity    hit   0.007167   0.000063   0.007230 (  0.007522)
identity    miss  0.008341   0.000026   0.008367 (  0.009288)
Object#hash hit   0.038703   0.000332   0.039035 (  0.041605)
Object#hash miss  0.037724   0.000206   0.037930 (  0.039403)
[:foo]#hash hit   0.081512   0.000432   0.081944 (  0.085705)
[:foo]#hash miss  0.066593   0.000292   0.066885 (  0.070274)
[[[]]]#hash hit   0.167103   0.000971   0.168074 (  0.188086)
[[{}]]#hash miss  0.080866   0.000497   0.081363 (  0.122520)

# after
$ ruby -v bench.rb
ruby 3.0.0dev (2020-12-23T20:38:25Z hash_optimize 7526bd357e) [x86_64-darwin18]
       user     system      total        real
empty loop        0.004705   0.000015   0.004720 (  0.004743)
identity    hit   0.007606   0.000070   0.007676 (  0.008335)
identity    miss  0.008555   0.000051   0.008606 (  0.008705)
Object#hash hit   0.013022   0.000095   0.013117 (  0.013822)
Object#hash miss  0.014614   0.000153   0.014767 (  0.016105)
[:foo]#hash hit   0.067296   0.000423   0.067719 (  0.069510)
[:foo]#hash miss  0.043778   0.000254   0.044032 (  0.045517)
[[[]]]#hash hit   0.158628   0.000632   0.159260 (  0.163153)
[[{}]]#hash miss  0.089682   0.000343   0.090025 (  0.092213)

require 'benchmark'

KEY = Class.new
KEY_MISS = Class.new
ARRAY = [:foo]
ARRAY_MISS = [:bar]
ARRAY2 = [[[]]]
ARRAY2_MISS = [[{}]]
CACHE = {KEY => 1, [:foo] => 1, [[[]]] => 1}
CACHE_BY_ID = CACHE.dup.compare_by_identity

N = 100_000
Benchmark.bm do |x|
  x.report('empty loop      ') { N.times{ } }
  x.report('identity    hit ') { N.times{ CACHE_BY_ID[KEY] } }
  x.report('identity    miss') { N.times{ CACHE_BY_ID[KEY_MISS] } }
  x.report('Object#hash hit ') { N.times{ CACHE[KEY] } }
  x.report('Object#hash miss') { N.times{ CACHE[KEY_MISS] } }
  x.report('[:foo]#hash hit ') { N.times{ CACHE[ARRAY] } }
  x.report('[:foo]#hash miss') { N.times{ CACHE[ARRAY_MISS] } }
  x.report('[[[]]]#hash hit ') { N.times{ CACHE[ARRAY2] } }
  x.report('[[{}]]#hash miss') { N.times{ CACHE[ARRAY2_MISS] } }
end

marcandre · 2020-12-23T21:50:36Z

Note that example with [:foo] is also faster, because Array#hash calls rb_hash on the Symbol, which also benefits from this optimization.
I've updated the benchmark to show timing for [[[]]]. That case does not benefit from this optimization but shows no big slowdown (unsurprisingly).

This avoids recursive checks when the `hash` method of an object isn't specialized.

marcandre · 2020-12-24T07:21:35Z

marcandre mentioned this pull request Dec 23, 2020

Encourage Hash#compare_by_identity fastruby/fast-ruby#189

Open

ko1 reviewed Dec 24, 2020

View reviewed changes

Comment thread include/ruby/internal/eval.h Outdated