Move replacement logic from all wrappers to the 3 classes that use it

Author: timfel

graalpython/com.oracle.graal.python.cext/src/capi.c

@@ -409,13 +409,7 @@ GraalPyPrivate_BulkDealloc(intptr_t ptrArray[], int64_t len)
 {
     for (int i = 0; i < len; i++) {
         PyObject *obj = (PyObject *)ptrArray[i];
-        if (!obj->ob_type) {
-            GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINER,
-                               "%s: Object: 0x%zx has no type anymore, we have "
-                               "no idea what it is, we will just free it",
-                               __func__, obj);
-            free(obj);
-        } else if (obj->ob_refcnt == _Py_IMMORTAL_REFCNT) {
+        if (obj->ob_refcnt == _Py_IMMORTAL_REFCNT) {
             GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINER,
                                "%s: Not deallocating immortal object: 0x%zx (%s%s)",
                                __func__, obj,

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

@@ -43,16 +43,11 @@
 import com.oracle.graal.python.builtins.objects.cext.capi.CExtNodes.ReleaseNativeWrapperNode;
 import com.oracle.graal.python.builtins.objects.cext.capi.PythonNativeWrapper.PythonStructNativeWrapper;
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions.PythonToNativeNode;
-import com.oracle.graal.python.builtins.objects.ints.PInt;
-import com.oracle.graal.python.nodes.ErrorMessages;
 import com.oracle.graal.python.runtime.PythonContext;
-import com.oracle.graal.python.util.OverflowException;
 import com.oracle.graal.python.util.PythonUtils;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.dsl.Cached;
-import com.oracle.truffle.api.dsl.Cached.Shared;
 import com.oracle.truffle.api.interop.InteropLibrary;
-import com.oracle.truffle.api.interop.InvalidArrayIndexException;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.library.ExportLibrary;
@@ -83,7 +78,7 @@ public CPyObjectArrayWrapper(Object[] delegate) {
         wrappers = new Object[delegate.length];
     }
 
-    public Object[] getObjectArray() {
+    private Object[] getObjectArray() {
         return ((Object[]) getDelegate());
     }
 
@@ -97,53 +92,15 @@ long asPointer() {
         return getNativePointer();
     }
 
-    @ExportMessage
-    long getArraySize() {
-        return wrappers.length;
-    }
-
-    @ExportMessage
-    @SuppressWarnings("static-method")
-    boolean hasArrayElements() {
-        return true;
-    }
-
-    @ExportMessage
-    Object readArrayElement(long index,
-                    @Shared("toNativeNode") @Cached PythonToNativeNode toNativeNode) throws InvalidArrayIndexException {
-        try {
-            int idx = PInt.intValueExact(index);
-            if (idx >= 0 && idx < wrappers.length) {
-                if (wrappers[idx] == null) {
-                    Object[] arr = getObjectArray();
-                    wrappers[idx] = toNativeNode.execute(arr[idx]);
-                }
-                return wrappers[idx];
-            }
-        } catch (OverflowException e) {
-            // fall through
-        }
-        CompilerDirectives.transferToInterpreterAndInvalidate();
-        throw InvalidArrayIndexException.create(index);
-    }
-
-    @ExportMessage
-    boolean isArrayElementReadable(long identifier) {
-        return 0 <= identifier && identifier < wrappers.length;
-    }
-
     /**
      * Copies a Java {@code Object[]} to a native {@code PyObject *arr[]}. For this, the native
      * memory is allocated off-heap using {@code Unsafe}.
      */
     @ExportMessage
     void toNative(
-                    @Shared("toNativeNode") @Cached PythonToNativeNode toNativeNode,
+                    @Cached PythonToNativeNode toNativeNode,
                     @CachedLibrary(limit = "3") InteropLibrary interopLib) {
-        if (!PythonContext.get(toNativeNode).isNativeAccessAllowed()) {
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-            throw new RuntimeException(ErrorMessages.NATIVE_ACCESS_NOT_ALLOWED.toJavaStringUncached());
-        }
+        assert PythonContext.get(toNativeNode).isNativeAccessAllowed();
         if (!isNative()) {
             Object[] data = getObjectArray();
             long ptr = allocateBoundary((long) wrappers.length * Long.BYTES);
@@ -175,10 +132,7 @@ public void free(ReleaseNativeWrapperNode releaseNativeWrapperNode) {
         // releaseNativeWrapperNode.execute(wrappers[i]);
         // }
         if (isNative()) {
-            if (!PythonContext.get(releaseNativeWrapperNode).isNativeAccessAllowed()) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                throw new RuntimeException(ErrorMessages.NATIVE_ACCESS_NOT_ALLOWED.toJavaStringUncached());
-            }
+            assert PythonContext.get(releaseNativeWrapperNode).isNativeAccessAllowed();
             freeBoundary(getNativePointer());
         }
     }

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

@@ -77,7 +77,7 @@ public abstract class ManagedMethodWrappers {
     public abstract static class MethodWrapper extends PythonStructNativeWrapper {
 
         public MethodWrapper(Object method) {
-            super(method, false);
+            super(method);
         }
 
         @ExportMessage

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

@@ -45,6 +45,7 @@
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions;
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions.PythonToNativeNode;
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitionsFactory.PythonToNativeNodeGen;
+import com.oracle.graal.python.builtins.objects.cext.common.NativePointer;
 import com.oracle.graal.python.builtins.objects.cext.structs.CFields;
 import com.oracle.graal.python.builtins.objects.cext.structs.CStructAccess;
 import com.oracle.graal.python.builtins.objects.cext.structs.CStructs;
@@ -66,6 +67,7 @@
  * </p>
  */
 public final class PThreadState extends PythonStructNativeWrapper {
+    private final Object replacement;
 
     /** Same as _PY_NSMALLNEGINTS */
     public static final int PY_NSMALLNEGINTS = 5;
@@ -75,12 +77,11 @@ public final class PThreadState extends PythonStructNativeWrapper {
 
     @TruffleBoundary
     private PThreadState(PythonThreadState threadState) {
-        super(threadState, true);
-        // TODO: this passes false for allocatedFromJava although we actually do allocate it from
-        // Java, but we currently free it on context exit using a call to
-        // FUN_PY_GC_COLLECT_NO_FAIL, which can bite us when we change allocators for the Java
-        // side...
-        replacement = registerReplacement(allocateCLayout(threadState), false, InteropLibrary.getUncached());
+        super(threadState);
+        long ptr = allocateCLayout(threadState);
+        CApiTransitions.createReference(this, ptr, true);
+        // TODO: wrap in NativePointer for NFI
+        replacement = new NativePointer(ptr);
     }
 
     public static Object getOrCreateNativeThreadState(PythonLanguage language, PythonContext context) {
@@ -109,10 +110,10 @@ public PythonThreadState getThreadState() {
     }
 
     @TruffleBoundary
-    private static Object allocateCLayout(PythonThreadState threadState) {
+    private static long allocateCLayout(PythonThreadState threadState) {
         PythonToNativeNode toNative = PythonToNativeNodeGen.getUncached();
 
-        Object ptr = CStructAccess.AllocateNode.allocUncached(CStructs.PyThreadState);
+        long ptr = CStructAccess.AllocateNode.allocUncachedPointer(CStructs.PyThreadState.size());
         CStructAccess.WritePointerNode writePtrNode = CStructAccess.WritePointerNode.getUncached();
         PythonContext pythonContext = PythonContext.get(null);
         PDict threadStateDict = threadState.getDict();

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

@@ -49,6 +49,7 @@
 import com.oracle.graal.python.builtins.objects.cext.capi.PythonNativeWrapper.PythonAbstractObjectNativeWrapper;
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions;
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions.PythonToNativeNewRefNode;
+import com.oracle.graal.python.builtins.objects.cext.common.NativePointer;
 import com.oracle.graal.python.builtins.objects.cext.structs.CFields;
 import com.oracle.graal.python.builtins.objects.cext.structs.CStructAccess;
 import com.oracle.graal.python.builtins.objects.cext.structs.CStructAccess.GetElementPtrNode;
@@ -59,19 +60,15 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
-import com.oracle.truffle.api.library.ExportLibrary;
-import com.oracle.truffle.api.library.ExportMessage;
 
 /**
  * Wrapper object for {@code PMemoryView}.
  */
-@ExportLibrary(InteropLibrary.class)
 public final class PyMemoryViewWrapper extends PythonAbstractObjectNativeWrapper {
-
     private Object replacement;
 
     public PyMemoryViewWrapper(PythonObject delegate) {
-        super(delegate, true);
+        super(delegate);
         assert delegate instanceof PMemoryView;
     }
 
@@ -82,16 +79,15 @@ private static Object intArrayToNativePySSizeArray(int[] intArray) {
     }
 
     @TruffleBoundary
-    private static Object allocate(PMemoryView object) {
+    private static long allocate(PMemoryView object) {
         GetElementPtrNode getElementNode = GetElementPtrNode.getUncached();
         CStructAccess.WritePointerNode writePointerNode = CStructAccess.WritePointerNode.getUncached();
         CStructAccess.WriteLongNode writeI64Node = CStructAccess.WriteLongNode.getUncached();
         CStructAccess.WriteIntNode writeI32Node = CStructAccess.WriteIntNode.getUncached();
         CExtNodes.AsCharPointerNode asCharPointerNode = CExtNodes.AsCharPointerNode.getUncached();
 
-        Object mem;
         long taggedPointer = CApiTransitions.FirstToNativeNode.executeUncached(object.getNativeWrapper(), true /*- TODO: immortal for now */);
-        mem = CApiTransitions.HandlePointerConverter.pointerToStub(taggedPointer);
+        long mem = CApiTransitions.HandlePointerConverter.pointerToStub(taggedPointer);
         writeI32Node.write(mem, PyMemoryViewObject__flags, object.getFlags());
         writeI64Node.write(mem, PyMemoryViewObject__exports, object.getExports().get());
         // TODO: ignoring mbuf, hash and weakreflist for now
@@ -150,37 +146,14 @@ private static Object allocate(PMemoryView object) {
 
     public Object getReplacement(InteropLibrary lib) {
         if (replacement == null) {
-            Object pointerObject = allocate((PMemoryView) getDelegate());
+            long ptr = allocate((PMemoryView) getDelegate());
+            // TODO: need to convert to interop pointer for NFI for now
+            replacement = new NativePointer(ptr);
             // TODO: this passes "false" for allocatedFromJava, although it actually is. The
             // problem, however, is that this struct contains nested allocations from Java. This
             // needs to be cleaned up...
-            replacement = registerReplacement(pointerObject, false, lib);
+            CApiTransitions.createReference(this, ptr, false);
         }
         return replacement;
     }
-
-    @ExportMessage
-    boolean isPointer() {
-        return isNative();
-    }
-
-    @ExportMessage
-    long asPointer() throws UnsupportedMessageException {
-        if (!isNative()) {
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-            throw UnsupportedMessageException.create();
-        }
-        return getNativePointer();
-    }
-
-    @ExportMessage
-    void toNative() {
-        if (!isNative()) {
-            /*
-             * This is a wrapper that is eagerly transformed to its C layout in the Python-to-native
-             * transition. Therefore, the wrapper is expected to be native already.
-             */
-            throw CompilerDirectives.shouldNotReachHere();
-        }
-    }
 }

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

@@ -120,7 +120,7 @@ public abstract class PyProcsWrapper extends PythonStructNativeWrapper {
     protected final CApiTiming timing;
 
     public PyProcsWrapper(Object delegate) {
-        super(delegate, false);
+        super(delegate);
         this.timing = CApiTiming.create(false, delegate);
     }
 

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

@@ -42,7 +42,9 @@
 
 import com.oracle.graal.python.builtins.objects.cext.PythonAbstractNativeObject;
 import com.oracle.graal.python.builtins.objects.cext.capi.PythonNativeWrapper.PythonAbstractObjectNativeWrapper;
+import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions;
 import com.oracle.graal.python.builtins.objects.cext.common.CArrayWrappers.CStringWrapper;
+import com.oracle.graal.python.builtins.objects.cext.common.NativePointer;
 import com.oracle.graal.python.builtins.objects.cext.structs.CFields;
 import com.oracle.graal.python.builtins.objects.cext.structs.CStructAccess;
 import com.oracle.graal.python.builtins.objects.cext.structs.CStructAccess.AllocateNode;
@@ -64,20 +66,18 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
-import com.oracle.truffle.api.library.ExportLibrary;
-import com.oracle.truffle.api.library.ExportMessage;
 import com.oracle.truffle.api.strings.TruffleString;
 
 /**
  * Used to wrap {@link PythonClass} when used in native code. This wrapper is replacing and the
  * replacement mimics the correct shape of the corresponding native type {@code struct _typeobject}.
  */
-@ExportLibrary(InteropLibrary.class)
 public final class PythonClassNativeWrapper extends PythonAbstractObjectNativeWrapper {
     private final CStringWrapper nameWrapper;
+    private Object replacement;
 
     private PythonClassNativeWrapper(PythonManagedClass object, TruffleString name, TruffleString.SwitchEncodingNode switchEncoding) {
-        super(object, true);
+        super(object);
         this.nameWrapper = new CStringWrapper(switchEncoding.execute(name, TruffleString.Encoding.UTF_8), TruffleString.Encoding.UTF_8);
     }
 
@@ -174,7 +174,13 @@ public static void wrapStaticTypeStructForManagedClass(PythonManagedClass clazz,
          * 'getReplacement' for more explanation).
          */
         wrapper.replacement = pointer;
-        wrapper.registerReplacement(pointer, false, lib);
+        long ptr;
+        try {
+            ptr = lib.asPointer(pointer);
+        } catch (UnsupportedMessageException e) {
+            throw CompilerDirectives.shouldNotReachHere(e);
+        }
+        CApiTransitions.createReference(wrapper, ptr, false);
     }
 
     public static void initNative(PythonManagedClass clazz, Object pointer) {
@@ -219,10 +225,11 @@ private void initializeReplacement(InteropLibrary lib) {
                 size = TypeNodes.GetBasicSizeNode.executeUncached(nativeMetatype);
             }
         }
-        Object pointerObject = AllocateNode.allocUncached(size);
-        replacement = registerReplacement(pointerObject, true, lib);
-
-        ToNativeTypeNode.initializeType(this, pointerObject, heaptype);
+        long ptr = AllocateNode.allocUncachedPointer(size);
+        // TODO: need to convert to interop pointer for NFI for now
+        replacement = new NativePointer(ptr);
+        CApiTransitions.createReference(this, ptr, true);
+        ToNativeTypeNode.initializeType(this, ptr, heaptype);
     }
 
     /**
@@ -231,29 +238,4 @@ private void initializeReplacement(InteropLibrary lib) {
     public Object getReplacementIfInitialized() {
         return replacement;
     }
-
-    @ExportMessage
-    boolean isPointer() {
-        return isNative();
-    }
-
-    @ExportMessage
-    long asPointer() throws UnsupportedMessageException {
-        if (!isNative()) {
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-            throw UnsupportedMessageException.create();
-        }
-        return getNativePointer();
-    }
-
-    @ExportMessage
-    void toNative() {
-        if (!isNative()) {
-            /*
-             * This is a wrapper that is eagerly transformed to its C layout in the Python-to-native
-             * transition. Therefore, the wrapper is expected to be native already.
-             */
-            throw CompilerDirectives.shouldNotReachHere();
-        }
-    }
 }