Add uncached fast-path for type.__call__ calls

Author: msimacek

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeBuiltins.java

@@ -172,6 +172,7 @@
 import com.oracle.truffle.api.dsl.GenerateCached;
 import com.oracle.truffle.api.dsl.GenerateInline;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
+import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.NeverDefault;
 import com.oracle.truffle.api.dsl.NodeFactory;
@@ -464,7 +465,7 @@ static Object init(@SuppressWarnings("unused") Object self, Object[] arguments,
     public abstract static class CallNode extends PythonVarargsBuiltinNode {
 
         @Specialization
-        Object call(VirtualFrame frame, Object self, Object[] arguments, PKeyword[] keywords,
+        static Object call(VirtualFrame frame, Object self, Object[] arguments, PKeyword[] keywords,
                         @Bind Node inliningTarget,
                         @Cached IsSameTypeNode isSameTypeNode,
                         @Cached GetClassNode getClassNode,
@@ -479,10 +480,16 @@ Object call(VirtualFrame frame, Object self, Object[] arguments, PKeyword[] keyw
             }
             return createInstanceNode.execute(frame, inliningTarget, self, arguments, keywords);
         }
+
+        public static Object executeUncached(VirtualFrame frame, Object self, Object[] arguments, PKeyword[] keywords) {
+            return call(frame, self, arguments, keywords,
+                            null, IsSameTypeNode.getUncached(), GetClassNode.getUncached(), PRaiseNode.getUncached(), TypeBuiltinsFactory.CreateInstanceNodeGen.getUncached());
+        }
     }
 
     @GenerateInline
     @GenerateCached(false)
+    @GenerateUncached
     protected abstract static class CreateInstanceNode extends PNodeWithContext {
 
         abstract Object execute(VirtualFrame frame, Node inliningTarget, Object self, Object[] args, PKeyword[] keywords);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeNodes.java

@@ -1479,6 +1479,10 @@ public static IsSameTypeNode create() {
             return IsSameTypeNodeGen.create();
         }
 
+        public static IsSameTypeNode getUncached() {
+            return IsSameTypeNodeGen.getUncached();
+        }
+
         @Specialization
         static boolean doManaged(PythonManagedClass left, PythonManagedClass right) {
             return left == right;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/CallNode.java

@@ -48,6 +48,7 @@
 import com.oracle.graal.python.builtins.objects.method.PBuiltinMethod;
 import com.oracle.graal.python.builtins.objects.type.TpSlots;
 import com.oracle.graal.python.builtins.objects.type.TpSlots.GetCachedTpSlotsNode;
+import com.oracle.graal.python.builtins.objects.type.TypeBuiltins;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotVarargs.CallSlotTpCallNode;
 import com.oracle.graal.python.nodes.ErrorMessages;
 import com.oracle.graal.python.nodes.PGuards;
@@ -185,7 +186,8 @@ static Object builtinMethodCall(VirtualFrame frame, PBuiltinMethod callable, Obj
     }
 
     @Fallback
-    static Object doGeneric(VirtualFrame frame, Object callableObject, Object[] arguments, PKeyword[] keywords,
+    @SuppressWarnings("truffle-static-method")
+    Object doGeneric(VirtualFrame frame, Object callableObject, Object[] arguments, PKeyword[] keywords,
                     @Bind Node inliningTarget,
                     @Cached PRaiseNode raise,
                     @Cached GetClassNode getClassNode,
@@ -194,6 +196,22 @@ static Object doGeneric(VirtualFrame frame, Object callableObject, Object[] argu
         Object type = getClassNode.execute(inliningTarget, callableObject);
         TpSlots slots = getSlots.execute(inliningTarget, type);
         if (slots.tp_call() != null) {
+            /*
+             * Uncached fast-path for type.__call__. This is not just for performance, but has
+             * "side-channel" effects. Without it, type.__call__'s needsCallerFrame assumption tends
+             * to get invalidated, which then causes frame sync at every subsequent uncached
+             * type.__call__ call. Frame syncs create new strong references to local variables (in
+             * CPython as well) and these spurious frame syncs cause failures in weakref-using
+             * tests.
+             */
+            if (CompilerDirectives.inInterpreter() && !isAdoptable() && slots.tp_call() == TypeBuiltins.SLOTS.tp_call()) {
+                /*
+                 * This node is often called from first-uncached bytecode execution, so it has the
+                 * frame despite being uncached. Passing it avoids stack walk when calling
+                 * super.__init__
+                 */
+                return TypeBuiltins.CallNode.executeUncached(frame, callableObject, arguments, keywords);
+            }
             return callSlot.execute(frame, inliningTarget, slots.tp_call(), callableObject, arguments, keywords);
         }
         throw raise.raise(inliningTarget, TypeError, ErrorMessages.OBJ_ISNT_CALLABLE, callableObject);