Introduce disposable call-cache.

This patch contains several ideas:

(1) Disposable inline method cache (IMC) for race-free inline method cache
    * Making call-cache (CC) as a RVALUE (GC target object) and allocate new
      CC on cache miss.
    * This technique allows race-free access from parallel processing
      elements like RCU.
(2) Introduce per-Class method cache (pCMC)
    * Instead of fixed-size global method cache (GMC), pCMC allows flexible
      cache size.
    * Caching CCs reduces CC allocation and allow sharing CC's fast-path
      between same call-info (CI) call-sites.
(3) Invalidate an inline method cache by invalidating corresponding method
    entries (MEs)
    * Instead of using class serials, we set "invalidated" flag for method
      entry itself to represent cache invalidation.
    * Compare with using class serials, the impact of method modification
      (add/overwrite/delete) is small.
    * Updating class serials invalidate all method caches of the class and
      sub-classes.
    * Proposed approach only invalidate the method cache of only one ME.

See [Feature #16614] for more details.

2 files changed, 67 insertions, 0 deletions

diff --git a/test/ruby/test_gc.rb b/test/ruby/test_gc.rb
index ef99f69f50..9442041ee5 100644
--- a/test/ruby/test_gc.rb
+++ b/test/ruby/test_gc.rb
@@ -94,6 +94,9 @@ class TestGc < Test::Unit::TestCase
     GC.start
     GC.stat(stat)
     ObjectSpace.count_objects(count)
+    # repeat same methods invocation for cache object creation.
+    GC.stat(stat)
+    ObjectSpace.count_objects(count) 
     assert_equal(count[:TOTAL]-count[:FREE], stat[:heap_live_slots])
     assert_equal(count[:FREE], stat[:heap_free_slots])
 
diff --git a/test/ruby/test_inlinecache.rb b/test/ruby/test_inlinecache.rb
new file mode 100644
index 0000000000..90d0189d4c
--- /dev/null
+++ b/test/ruby/test_inlinecache.rb
@@ -0,0 +1,64 @@
+# -*- coding: us-ascii -*-
+# frozen_string_literal: true
+
+require 'test/unit'
+
+class TestMethod < Test::Unit::TestCase
+  def test_alias
+    m0 = Module.new do
+      def foo; :M0 end
+    end
+    m1 = Module.new do
+      include m0
+    end
+    c = Class.new do
+      include m1
+      alias bar foo
+    end
+    d = Class.new(c) do
+    end
+
+    test = -> do
+      d.new.bar
+    end
+
+    assert_equal :M0, test[]
+
+    c.class_eval do
+      def bar
+        :C
+      end
+    end
+
+    assert_equal :C, test[]
+  end
+
+  def test_zsuper
+    assert_separately [], <<-EOS
+      class C
+        private def foo
+          :C
+        end
+      end
+
+      class D < C
+        public :foo
+      end
+
+      class E < D; end
+      class F < E; end
+
+      test = -> do
+        F.new().foo
+      end
+
+      assert_equal :C, test[]
+
+      class E
+        def foo; :E; end
+      end
+
+      assert_equal :E, test[]
+    EOS
+  end
+end