[GR-58076] Cache most of the CallTargets even in single context mode.

PullRequest: graalpython/3477

Author: steve-s

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/PythonLanguage.java

@@ -1057,34 +1057,40 @@ public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode>
         // be appropriate keys for the cache
         assert RootNode.class.isAssignableFrom(key) || key.getConstructors().length <= 1;
         assert RootNode.class.isAssignableFrom(key) || key.getConstructors().length == 0 || key.getConstructors()[0].getParameterCount() == 0;
-        return createCachedCallTargetUnsafe(rootNodeFunction, key);
+        return createCachedCallTargetUnsafe(rootNodeFunction, key, true);
     }
 
     public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Enum<?> key) {
-        return createCachedCallTargetUnsafe(rootNodeFunction, key);
+        return createCachedCallTargetUnsafe(rootNodeFunction, key, true);
     }
 
     public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Class<? extends Node> nodeClass, String key) {
         // for builtins: name is needed to distinguish builtins that share the same underlying node
         // in general: a String may be parameter of the node wrapped in the root node or the root
         // node itself, there must be finite number of strings that can appear here (i.e., must not
         // be dynamically generated unless their number is bounded).
-        return createCachedCallTargetUnsafe(rootNodeFunction, nodeClass, key);
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, nodeClass, key);
+    }
+
+    // Variant that should be called at most once per context, because it does not cache the target
+    // in single context mode
+    public RootCallTarget initBuiltinCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Class<? extends Node> nodeClass, String key) {
+        return createCachedCallTargetUnsafe(rootNodeFunction, false, nodeClass, key);
     }
 
     public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Class<? extends Node> nodeClass, TruffleString key) {
         // See the String overload
-        return createCachedCallTargetUnsafe(rootNodeFunction, nodeClass, key);
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, nodeClass, key);
     }
 
     public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Class<? extends Node> nodeClass, int key) {
-        return createCachedCallTargetUnsafe(rootNodeFunction, nodeClass, key);
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, nodeClass, key);
     }
 
     public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Class<? extends Node> nodeClass1, Class<?> nodeClass2, String name) {
         // for slot wrappers: the root node may be wrapping a helper wrapper node implementing the
         // wrapper logic and the bare slot node itself
-        return createCachedCallTargetUnsafe(rootNodeFunction, nodeClass1, nodeClass2, name);
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, nodeClass1, nodeClass2, name);
     }
 
     /**
@@ -1094,28 +1100,29 @@ public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode>
      * functions. This may hold onto call targets created by one extension used in a context that
      * was closed in the meanwhile and no other context ever loads the extension.
      */
-    public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Class<? extends RootNode> klass, Enum<?> signature, TruffleString name,
-                    boolean doArgumentAndResultConversion) {
-        return createCachedCallTargetUnsafe(rootNodeFunction, klass, signature, name, doArgumentAndResultConversion);
+    public RootCallTarget createCachedExternalFunWrapperCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction,
+                    Class<? extends RootNode> klass, Enum<?> signature, TruffleString name,
+                    boolean doArgumentAndResultConversion, boolean isStatic) {
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, klass, signature, name, doArgumentAndResultConversion, isStatic);
     }
 
     public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Enum<?> signature, TruffleString name,
                     boolean doArgumentAndResultConversion) {
-        return createCachedCallTargetUnsafe(rootNodeFunction, signature, name, doArgumentAndResultConversion);
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, signature, name, doArgumentAndResultConversion);
     }
 
     public RootCallTarget createCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Enum<?> signature, TruffleString name) {
-        return createCachedCallTargetUnsafe(rootNodeFunction, signature, name);
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, signature, name);
     }
 
     public RootCallTarget createStructSeqIndexedMemberAccessCachedCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, int memberIndex) {
-        return createCachedCallTargetUnsafe(rootNodeFunction, StructSequence.class, memberIndex);
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, StructSequence.class, memberIndex);
     }
 
     public RootCallTarget createCachedPropAccessCallTarget(Function<PythonLanguage, RootNode> rootNodeFunction, Class<?> nodeClass, String name, int type, int offset) {
         // For the time being, we assume finite/limited number of cext/hpy types members, their
         // types and offsets
-        return createCachedCallTargetUnsafe(rootNodeFunction, nodeClass, name, type, offset);
+        return createCachedCallTargetUnsafe(rootNodeFunction, true, nodeClass, name, type, offset);
     }
 
     /**
@@ -1128,17 +1135,17 @@ public RootCallTarget createCachedPropAccessCallTarget(Function<PythonLanguage,
      * instances. Public methods for adding to the cache must take concrete key type(s) so that all
      * possible cache keys are explicit and documented.
      */
-    private RootCallTarget createCachedCallTargetUnsafe(Function<PythonLanguage, RootNode> rootNodeFunction, Object key) {
+    private RootCallTarget createCachedCallTargetUnsafe(Function<PythonLanguage, RootNode> rootNodeFunction, Object key, boolean cacheInSingleContext) {
         CompilerAsserts.neverPartOfCompilation();
-        if (!singleContext) {
+        if (cacheInSingleContext || !singleContext) {
             return cachedCallTargets.computeIfAbsent(key, k -> PythonUtils.getOrCreateCallTarget(rootNodeFunction.apply(this)));
         } else {
             return PythonUtils.getOrCreateCallTarget(rootNodeFunction.apply(this));
         }
     }
 
-    private RootCallTarget createCachedCallTargetUnsafe(Function<PythonLanguage, RootNode> rootNodeFunction, Object... cacheKeys) {
-        return createCachedCallTargetUnsafe(rootNodeFunction, Arrays.asList(cacheKeys));
+    private RootCallTarget createCachedCallTargetUnsafe(Function<PythonLanguage, RootNode> rootNodeFunction, boolean cacheInSingleContext, Object... cacheKeys) {
+        return createCachedCallTargetUnsafe(rootNodeFunction, Arrays.asList(cacheKeys), cacheInSingleContext);
     }
 
     public void registerBuiltinDescriptorCallTarget(BuiltinMethodDescriptor descriptor, RootCallTarget callTarget) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltins.java

@@ -173,7 +173,7 @@ public void initialize(Python3Core core) {
                 declaresExplicitSelf = true;
             }
             TruffleString tsName = toTruffleStringUncached(builtin.name());
-            RootCallTarget callTarget = core.getLanguage().createCachedCallTarget(l -> new BuiltinFunctionRootNode(l, builtin, factory, declaresExplicitSelf), factory.getNodeClass(),
+            RootCallTarget callTarget = core.getLanguage().initBuiltinCallTarget(l -> new BuiltinFunctionRootNode(l, builtin, factory, declaresExplicitSelf), factory.getNodeClass(),
                             builtin.name());
             Object builtinDoc = builtin.doc().isEmpty() ? PNone.NONE : toTruffleStringUncached(builtin.doc());
             int flags = PBuiltinFunction.getFlags(builtin, callTarget);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/cext/PythonCextTypeBuiltins.java

@@ -448,13 +448,13 @@ static GetSetDescriptor createGetSet(Node inliningTarget, TruffleString name, Ob
         @TruffleBoundary
         private static RootCallTarget getterCallTarget(TruffleString name, PythonLanguage lang) {
             Function<PythonLanguage, RootNode> rootNodeFunction = l -> new GetterRoot(l, name, PExternalFunctionWrapper.GETTER);
-            return lang.createCachedCallTarget(rootNodeFunction, GetterRoot.class, PExternalFunctionWrapper.GETTER, name, true);
+            return lang.createCachedExternalFunWrapperCallTarget(rootNodeFunction, GetterRoot.class, PExternalFunctionWrapper.GETTER, name, true, false);
         }
 
         @TruffleBoundary
         private static RootCallTarget setterCallTarget(TruffleString name, PythonLanguage lang) {
             Function<PythonLanguage, RootNode> rootNodeFunction = l -> new SetterRoot(l, name, PExternalFunctionWrapper.SETTER);
-            return lang.createCachedCallTarget(rootNodeFunction, SetterRoot.class, PExternalFunctionWrapper.SETTER, name, true);
+            return lang.createCachedExternalFunWrapperCallTarget(rootNodeFunction, SetterRoot.class, PExternalFunctionWrapper.SETTER, name, true, false);
         }
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/capi/ExternalFunctionNodes.java

@@ -620,7 +620,7 @@ static RootCallTarget getOrCreateCallTarget(PExternalFunctionWrapper sig, Python
                 default:
                     throw CompilerDirectives.shouldNotReachHere();
             }
-            return language.createCachedCallTarget(rootNodeFunction, nodeKlass, sig, name, doArgAndResultConversion);
+            return language.createCachedExternalFunWrapperCallTarget(rootNodeFunction, nodeKlass, sig, name, doArgAndResultConversion, isStatic);
         }
 
         public static PBuiltinFunction createWrapperFunction(TruffleString name, Object callable, Object enclosingType, int flags, int sig,