Cache Symbol#to_proc by DeclarationContext

Author: bjfish

src/main/java/org/truffleruby/core/inlined/CoreMethods.java

@@ -85,6 +85,7 @@ public class CoreMethods {
     public final InternalMethod STRING_BYTESIZE;
     public final InternalMethod MODULE_CASE_EQUAL;
     public final InternalMethod STRING_EQUAL;
+    public final InternalMethod SYMBOL_TO_PROC;
 
     public CoreMethods(RubyContext context) {
         this.context = context;
@@ -96,6 +97,7 @@ public CoreMethods(RubyContext context) {
         final RubyClass moduleClass = context.getCoreLibrary().moduleClass;
         final RubyClass nilClass = context.getCoreLibrary().nilClass;
         final RubyClass stringClass = context.getCoreLibrary().stringClass;
+        final RubyClass symbolClass = context.getCoreLibrary().symbolClass;
 
         integerNegAssumption = registerAssumption(integerClass, "-@");
         floatNegAssumption = registerAssumption(floatClass, "-@");
@@ -143,6 +145,7 @@ public CoreMethods(RubyContext context) {
         KERNEL_KIND_OF = getMethod(kernelModule, "kind_of?");
         MODULE_CASE_EQUAL = getMethod(moduleClass, "===");
         STRING_EQUAL = getMethod(stringClass, "==");
+        SYMBOL_TO_PROC = getMethod(symbolClass, "to_proc");
     }
 
     private Assumption registerAssumption(RubyClass klass, String methodName) {

src/main/java/org/truffleruby/core/symbol/RubySymbol.java

@@ -13,6 +13,7 @@
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.Hashing;
 import org.truffleruby.core.klass.RubyClass;
+import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.rope.Rope;
 import org.truffleruby.language.ImmutableRubyObject;
 
@@ -23,6 +24,10 @@
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.library.ExportLibrary;
 import com.oracle.truffle.api.library.ExportMessage;
+import org.truffleruby.language.methods.DeclarationContext;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 @ExportLibrary(InteropLibrary.class)
 public final class RubySymbol extends ImmutableRubyObject implements TruffleObject {
@@ -35,6 +40,7 @@ public final class RubySymbol extends ImmutableRubyObject implements TruffleObje
     private final Rope rope;
     private final int javaStringHashCode;
     private final long id;
+    private final ConcurrentMap<DeclarationContext, RubyProc> cachedProcs = new ConcurrentHashMap<>();
 
     public RubySymbol(String string, Rope rope, long id) {
         this.string = string;
@@ -59,6 +65,10 @@ public Rope getRope() {
         return rope;
     }
 
+    public ConcurrentMap<DeclarationContext, RubyProc> getCachedProcs() {
+        return cachedProcs;
+    }
+
     public long computeHashCode(Hashing hashing) {
         return hashing.hash(CLASS_SALT, javaStringHashCode);
     }

src/main/java/org/truffleruby/core/symbol/SymbolNodes.java

@@ -13,6 +13,7 @@
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.UnaryCoreMethodNode;
+import org.truffleruby.collections.ConcurrentOperations;
 import org.truffleruby.core.CoreLibrary;
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.core.klass.RubyClass;
@@ -105,20 +106,28 @@ public abstract static class ToProcNode extends CoreMethodArrayArgumentsNode {
         protected RubyProc toProcCached(VirtualFrame frame, RubySymbol symbol,
                 @Cached("symbol") RubySymbol cachedSymbol,
                 @Cached("getDeclarationContext(frame)") DeclarationContext cachedDeclarationContext,
-                @Cached("createProc(cachedDeclarationContext, getMethod(frame), symbol)") RubyProc cachedProc) {
+                @Cached("getOrCreateProc(cachedDeclarationContext, symbol)") RubyProc cachedProc) {
             return cachedProc;
         }
 
         @Specialization
         protected RubyProc toProcUncached(VirtualFrame frame, RubySymbol symbol) {
-            final InternalMethod method = getMethod(frame);
             DeclarationContext declarationContext = getDeclarationContext(frame);
-            return createProc(declarationContext, method, symbol);
+            return getOrCreateProc(declarationContext, symbol);
         }
 
         @TruffleBoundary
-        protected RubyProc createProc(DeclarationContext declarationContext, InternalMethod method,
-                RubySymbol symbol) {
+        protected RubyProc getOrCreateProc(DeclarationContext declarationContext, RubySymbol symbol) {
+            declarationContext = declarationContext == null ? DeclarationContext.NONE : declarationContext;
+            return ConcurrentOperations.getOrCompute(
+                    symbol.getCachedProcs(),
+                    declarationContext,
+                    key -> createProc(key, symbol));
+        }
+
+        @TruffleBoundary
+        protected RubyProc createProc(DeclarationContext declarationContext, RubySymbol symbol) {
+            final InternalMethod method = getContext().getCoreMethods().SYMBOL_TO_PROC;
             final SourceSection sourceSection = CoreLibrary.UNAVAILABLE_SOURCE_SECTION;
             final SharedMethodInfo sharedMethodInfo = new SharedMethodInfo(
                     sourceSection,
@@ -157,7 +166,7 @@ protected RubyProc createProc(DeclarationContext declarationContext, InternalMet
                     method,
                     null,
                     null,
-                    declarationContext == null ? DeclarationContext.NONE : declarationContext);
+                    declarationContext);
         }
 
         protected InternalMethod getMethod(VirtualFrame frame) {