Introduce PythonObjectSlowPathFactory and use it in JNI upcalls

fangerer · fangerer · commit 14a450fc47d2 · 2021-09-03T15:49:30.000+02:00
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/hpy/GraalHPyContext.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/hpy/GraalHPyContext.java
@@ -165,7 +165,6 @@
 import com.oracle.graal.python.builtins.objects.type.PythonClass;
 import com.oracle.graal.python.builtins.objects.type.SpecialMethodSlot;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.IsTypeNode;
-import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetInstanceShapeNodeGen;
 import com.oracle.graal.python.lib.CanBeDoubleNodeGen;
 import com.oracle.graal.python.lib.PyFloatAsDoubleNodeGen;
 import com.oracle.graal.python.lib.PyIndexCheckNodeGen;
@@ -193,6 +192,7 @@
 import com.oracle.graal.python.runtime.exception.PException;
 import com.oracle.graal.python.runtime.exception.PythonThreadKillException;
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
+import com.oracle.graal.python.runtime.object.PythonObjectSlowPathFactory;
 import com.oracle.graal.python.runtime.sequence.PSequence;
 import com.oracle.graal.python.runtime.sequence.storage.DoubleSequenceStorage;
 import com.oracle.graal.python.runtime.sequence.storage.IntSequenceStorage;
@@ -761,6 +761,8 @@ public static GraalHPyNativeSymbol getGetterFunctionName(LLVMType llvmType) {
     @CompilationFinal private RootCallTarget referenceCleanerCallTarget;
     private Thread hpyReferenceCleanerThread;
 
+    private PythonObjectSlowPathFactory slowPathFactory;
+
     public GraalHPyContext(PythonContext context, Object hpyLibrary) {
         super(context, hpyLibrary, GraalHPyConversionNodeSupplier.HANDLE);
         this.hpyContextMembers = createMembers(context, getName());
@@ -1284,6 +1286,17 @@ void increment() {
         }
     }
 
+    /**
+     * Returns a Python object factory that should only be used on the slow path. The factory object
+     * is initialized lazily.
+     */
+    private PythonObjectSlowPathFactory factory() {
+        if (slowPathFactory == null) {
+            slowPathFactory = new PythonObjectSlowPathFactory(getContext().getAllocationReporter());
+        }
+        return slowPathFactory;
+    }
+
     @SuppressWarnings("static-method")
     public final long ctxFloatFromDouble(double value) {
         Counter.UpcallFloatFromDouble.increment();
@@ -1353,14 +1366,17 @@ public final long ctxNew(long typeHandle, long dataOutVar) {
             long basicSize = clazz.basicSize;
             if (basicSize == -1) {
                 // create the managed Python object
-                pythonObject = new PythonObject(clazz, clazz.getInstanceShape());
+                pythonObject = factory().createPythonObject(clazz, clazz.getInstanceShape());
             } else {
+                /*
+                 * Since this is a JNI upcall method, we know that (1) we are not running in some
+                 * managed mode, and (2) the data will be used in real native code. Hence, we can
+                 * immediately allocate native memory via Unsafe.
+                 */
                 long dataPtr = unsafe.allocateMemory(basicSize);
                 unsafe.setMemory(dataPtr, basicSize, (byte) 0);
                 unsafe.putLong(dataOutVar, dataPtr);
-                // create the managed Python object
-                pythonObject = new PythonHPyObject(clazz, clazz.getInstanceShape(), dataPtr);
-                // we fully control this attribute; if it is there, it's always a long
+                pythonObject = factory().createPythonHPyObject(clazz, dataPtr);
                 Object destroyFunc = clazz.hpyDestroyFunc;
                 createHandleReference(pythonObject, dataPtr, destroyFunc != PNone.NO_VALUE ? destroyFunc : null);
             }
@@ -1370,7 +1386,7 @@ public final long ctxNew(long typeHandle, long dataOutVar) {
                 return HPyRaiseNodeGen.getUncached().raiseIntWithoutFrame(this, 0, PythonBuiltinClassType.TypeError, "HPy_New arg 1 must be a type");
             }
             // TODO(fa): this should actually call __new__
-            pythonObject = new PythonObject(type, GetInstanceShapeNodeGen.getUncached().execute(type));
+            pythonObject = factory().createPythonObject(type);
         }
         return GraalHPyBoxing.boxHandle(createHandle(pythonObject).getId(this, ConditionProfile.getUncached()));
     }
@@ -1389,10 +1405,9 @@ public final long ctxTypeGenericNew(long typeHandle) {
                 // allocate native space
                 long dataPtr = unsafe.allocateMemory(basicSize);
                 unsafe.setMemory(dataPtr, basicSize, (byte) 0);
-                pythonObject = new PythonHPyObject(clazz, clazz.getInstanceShape(), dataPtr);
+                pythonObject = factory().createPythonHPyObject(clazz, dataPtr);
             } else {
-                // create the managed Python object
-                pythonObject = new PythonObject(clazz, clazz.getInstanceShape());
+                pythonObject = factory().createPythonObject(clazz);
             }
             return GraalHPyBoxing.boxHandle(createHandle(pythonObject).getId(this, ConditionProfile.getUncached()));
         }
@@ -1416,14 +1431,14 @@ public final long ctxDup(long handle) {
         }
     }
 
-    public final long ctxGetItemi(long handle, long lidx) {
+    public final long ctxGetItemi(long hCollection, long lidx) {
         Counter.UpcallGetItemI.increment();
         try {
-            // If handle 'hSequence' is a boxed int or double, the object is not subscriptable.
-            if (!GraalHPyBoxing.isBoxedHandle(handle)) {
+            // If handle 'hCollection' is a boxed int or double, the object is not subscriptable.
+            if (!GraalHPyBoxing.isBoxedHandle(hCollection)) {
                 throw PRaiseNode.raiseUncached(null, PythonBuiltinClassType.TypeError, ErrorMessages.OBJ_NOT_SUBSCRIPTABLE, 0);
             }
-            Object receiver = getObjectForHPyHandle(GraalHPyBoxing.unboxHandle(handle)).getDelegate();
+            Object receiver = getObjectForHPyHandle(GraalHPyBoxing.unboxHandle(hCollection)).getDelegate();
             Object clazz = GetClassNode.getUncached().execute(receiver);
             if (clazz == PythonBuiltinClassType.PList || clazz == PythonBuiltinClassType.PTuple) {
                 if (!PInt.isIntRange(lidx)) {
@@ -1577,7 +1592,7 @@ public final int ctxNumberCheck(long handle) {
                 return 1;
             }
             Object receiverType = GetClassNode.getUncached().execute(receiver);
-            return com.oracle.graal.python.builtins.objects.ints.PInt.intValue(LookupCallableSlotInMRONode.getUncached(SpecialMethodSlot.Int).execute(receiverType) != PNone.NO_VALUE);
+            return PInt.intValue(LookupCallableSlotInMRONode.getUncached(SpecialMethodSlot.Int).execute(receiverType) != PNone.NO_VALUE);
         } catch (PException e) {
             HPyTransformExceptionToNativeNodeGen.getUncached().execute(this, e);
             return 0;
@@ -1607,10 +1622,9 @@ public final long ctxLength(long handle) {
     public final int ctxListCheck(long handle) {
         Counter.UpcallListCheck.increment();
         if (GraalHPyBoxing.isBoxedHandle(handle)) {
-
             Object obj = getObjectForHPyHandle(GraalHPyBoxing.unboxHandle(handle)).getDelegate();
             Object clazz = GetClassNode.getUncached().execute(obj);
-            return com.oracle.graal.python.builtins.objects.ints.PInt.intValue(clazz == PythonBuiltinClassType.PList || IsSubtypeNodeGen.getUncached().execute(clazz, PythonBuiltinClassType.PList));
+            return PInt.intValue(clazz == PythonBuiltinClassType.PList || IsSubtypeNodeGen.getUncached().execute(clazz, PythonBuiltinClassType.PList));
         } else {
             return 0;
         }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/object/PythonObjectSlowPathFactory.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/object/PythonObjectSlowPathFactory.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.graal.python.runtime.object;
+
+import java.util.Objects;
+
+import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetInstanceShapeNodeGen;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.instrumentation.AllocationReporter;
+import com.oracle.truffle.api.nodes.NodeCost;
+import com.oracle.truffle.api.object.Shape;
+
+/**
+ * A subclass of {@link PythonObjectFactory} which is basically an uncached version of it but
+ * directly stores a reference to the {@link AllocationReporter} instead of doing a context lookup
+ * and getting it from the context. This class is meant to be used on slow path where the context is
+ * explicitly available.
+ */
+public final class PythonObjectSlowPathFactory extends PythonObjectFactory {
+
+    private final AllocationReporter reporter;
+
+    public PythonObjectSlowPathFactory(AllocationReporter reporter) {
+        this.reporter = Objects.requireNonNull(reporter);
+    }
+
+    @TruffleBoundary
+    @Override
+    protected AllocationReporter executeTrace(Object arg0Value, long arg1Value) {
+        return PythonObjectFactory.doTrace(arg0Value, arg1Value, reporter);
+    }
+
+    @TruffleBoundary
+    @Override
+    protected Shape executeGetShape(Object arg0Value, boolean arg1Value) {
+        return PythonObjectFactory.getShape(arg0Value, arg1Value, (GetInstanceShapeNodeGen.getUncached()));
+    }
+
+    @Override
+    public NodeCost getCost() {
+        return NodeCost.MEGAMORPHIC;
+    }
+
+    @Override
+    public boolean isAdoptable() {
+        return false;
+    }
+
+}
