Use eager native tuple allocation in tp_init

Author: msimacek

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

@@ -150,6 +150,9 @@
 import com.oracle.truffle.api.dsl.GenerateInline;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.ImportStatic;
+import com.oracle.truffle.api.dsl.InlineSupport.InlineTarget;
+import com.oracle.truffle.api.dsl.InlineSupport.RequiredField;
+import com.oracle.truffle.api.dsl.InlineSupport.StateField;
 import com.oracle.truffle.api.dsl.NeverDefault;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.exception.AbstractTruffleException;
@@ -2141,6 +2144,52 @@ private ReadIndexedArgumentNode ensureReadArgNode() {
         }
     }
 
+    /**
+     * An inlined node-like object for keeping track of eager native allocation state bit. Should be
+     * {@code @Cached} and passed into
+     * {@link CreateArgsTupleNode#execute(Node, PythonLanguage, Object[], EagerTupleState)}. Then
+     * the {@link #report(Node, PTuple)} method should be called with the tuple after the native
+     * call returns.
+     */
+    public static final class EagerTupleState {
+        private final StateField state;
+
+        private static final EagerTupleState UNCACHED = new EagerTupleState();
+
+        private EagerTupleState() {
+            this.state = null;
+        }
+
+        private EagerTupleState(InlineTarget target) {
+            this.state = target.getState(0, 1);
+        }
+
+        public boolean isEager(Node inliningTarget) {
+            if (state == null) {
+                return false;
+            }
+            return state.get(inliningTarget) != 0;
+        }
+
+        public void report(Node inliningTarget, PTuple tuple) {
+            if (state != null) {
+                if (!isEager(inliningTarget) && tuple.getSequenceStorage() instanceof NativeSequenceStorage) {
+                    CompilerDirectives.transferToInterpreterAndInvalidate();
+                    state.set(inliningTarget, 1);
+                }
+            }
+        }
+
+        public static EagerTupleState inline(
+                        @RequiredField(value = StateField.class, bits = 1) InlineTarget target) {
+            return new EagerTupleState(target);
+        }
+
+        public static EagerTupleState getUncached() {
+            return UNCACHED;
+        }
+    }
+
     /**
      * We need to inflate all primitives in order to avoid memory leaks. Explanation: Primitives
      * would currently be wrapped into a PrimitiveNativeWrapper. If any of those will receive a
@@ -2154,6 +2203,10 @@ private ReadIndexedArgumentNode ensureReadArgNode() {
     public abstract static class CreateArgsTupleNode extends Node {
         public abstract PTuple execute(PythonLanguage language, Object[] args, boolean eagerNative);
 
+        public final PTuple execute(Node inliningTarget, PythonLanguage language, Object[] args, EagerTupleState state) {
+            return execute(language, args, state.isEager(inliningTarget));
+        }
+
         @Specialization(guards = {"args.length == cachedLen", "cachedLen <= 8", "!eagerNative"}, limit = "1")
         @ExplodeLoop(kind = LoopExplosionKind.FULL_UNROLL)
         static PTuple doCachedLen(PythonLanguage language, Object[] args, @SuppressWarnings("unused") boolean eagerNative,

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

@@ -50,6 +50,7 @@
 import com.oracle.graal.python.builtins.PythonBuiltins;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.CreateArgsTupleNode;
+import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.EagerTupleState;
 import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.ExternalFunctionInvokeNode;
 import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.InitCheckFunctionResultNode;
 import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.PExternalFunctionWrapper;
@@ -58,6 +59,7 @@
 import com.oracle.graal.python.builtins.objects.function.PBuiltinFunction;
 import com.oracle.graal.python.builtins.objects.function.PKeyword;
 import com.oracle.graal.python.builtins.objects.function.Signature;
+import com.oracle.graal.python.builtins.objects.tuple.PTuple;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotBuiltin;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotPythonSingle;
 import com.oracle.graal.python.nodes.ErrorMessages;
@@ -263,16 +265,17 @@ static void callNative(VirtualFrame frame, Node inliningTarget, TpSlot.TpSlotCEx
                         @Cached GetThreadStateNode getThreadStateNode,
                         @Cached(inline = false) PythonToNativeNode toNativeNode,
                         @Cached CreateArgsTupleNode createArgsTupleNode,
+                        @Cached EagerTupleState eagerTupleState,
                         @Cached ExternalFunctionInvokeNode externalInvokeNode,
                         @Cached InitCheckFunctionResultNode checkResult) {
             PythonLanguage language = context.getLanguage(inliningTarget);
             PythonThreadState state = getThreadStateNode.execute(inliningTarget, context);
-            // TODO eager native tuple
-            Object argsTuple = createArgsTupleNode.execute(language, args, false);
+            PTuple argsTuple = createArgsTupleNode.execute(inliningTarget, language, args, eagerTupleState);
             Object kwargsDict = PFactory.createDict(language, keywords);
             Object nativeResult = externalInvokeNode.call(frame, inliningTarget, state, C_API_TIMING, T___INIT__, slot.callable,
                             toNativeNode.execute(self), toNativeNode.execute(argsTuple), toNativeNode.execute(kwargsDict));
             checkResult.execute(state, T___INIT__, nativeResult);
+            eagerTupleState.report(inliningTarget, argsTuple);
         }
 
         @Specialization(replaces = "callCachedBuiltin")