Cache Method#to_proc result's call target in global cache

Author: andrykonchin

src/main/java/org/truffleruby/core/method/MethodNodes.java

@@ -285,30 +285,18 @@ RubyUnboundMethod unbind(RubyMethod method,
     @CoreMethod(names = "to_proc")
     public abstract static class ToProcNode extends CoreMethodArrayArgumentsNode {
 
-        @Specialization(guards = { "isSingleContext()", "methodObject == cachedMethodObject" },
-                limit = "getCacheLimit()")
-        RubyProc toProcCachedSingleContext(RubyMethod methodObject,
-                @Cached("methodObject") RubyMethod cachedMethodObject,
-                @Cached("toProcUncached(cachedMethodObject)") RubyProc proc) {
-            return proc;
-        }
-
-        @Specialization(
-                guards = "methodObject.method.getCallTarget() == methodCallTarget",
-                limit = "getCacheLimit()",
-                replaces = "toProcCachedSingleContext")
-        RubyProc toProcCachedTarget(RubyMethod methodObject,
-                @Cached("methodObject.method.getCallTarget()") RootCallTarget methodCallTarget,
-                @Cached("procCallTargetToCallRubyMethod(methodCallTarget)") RootCallTarget procCallTarget) {
-            return createProc(procCallTarget, methodObject.method, methodObject.receiver);
-        }
-
-        @Specialization(replaces = { "toProcCachedSingleContext", "toProcCachedTarget" })
-        RubyProc toProcUncached(RubyMethod methodObject) {
+        @Specialization
+        RubyProc toProc(RubyMethod methodObject) {
             final InternalMethod method = methodObject.method;
             final Object receiver = methodObject.receiver;
-            final RootCallTarget callTarget = procCallTargetToCallRubyMethod(method.getCallTarget());
-            return createProc(callTarget, method, receiver);
+            RootCallTarget toProcCallTarget = method.toProcCallTarget;
+
+            if (toProcCallTarget == null) {
+                toProcCallTarget = createToProcCallTarget(method.getCallTarget());
+                method.toProcCallTarget = toProcCallTarget;
+            }
+
+            return createProc(toProcCallTarget, method, receiver);
         }
 
         private RubyProc createProc(RootCallTarget callTarget, InternalMethod method, Object receiver) {
@@ -331,7 +319,7 @@ private RubyProc createProc(RootCallTarget callTarget, InternalMethod method, Ob
         }
 
         @TruffleBoundary
-        protected RootCallTarget procCallTargetToCallRubyMethod(RootCallTarget callTarget) {
+        protected RootCallTarget createToProcCallTarget(RootCallTarget callTarget) {
             // translate to something like:
             // lambda { |same args list| method.call(args) }
             // We need to preserve the method receiver and we want to have the same argument list.
@@ -354,10 +342,6 @@ protected RootCallTarget procCallTargetToCallRubyMethod(RootCallTarget callTarge
             return wrapRootNode.getCallTarget();
         }
 
-        protected int getCacheLimit() {
-            return getLanguage().options.METHOD_TO_PROC_CACHE;
-        }
-
         private static final class CallWithRubyMethodReceiverNode extends RubyContextSourceNode {
             @Child private CallInternalMethodNode callInternalMethodNode = CallInternalMethodNode.create();
 

src/main/java/org/truffleruby/language/methods/InternalMethod.java

@@ -57,6 +57,9 @@ public final class InternalMethod implements ObjectGraphNode {
     private final CachedLazyCallTargetSupplier callTargetSupplier;
     @CompilationFinal private RootCallTarget callTarget;
 
+    /** call target of a Proc created from a method and cached for consequent Method#to_proc calls */
+    public RootCallTarget toProcCallTarget;
+
     public static InternalMethod fromProc(
             RubyContext context,
             SharedMethodInfo sharedMethodInfo,