Get rid of NativeObjectReferenceArrayWrapper

Author: timfel

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

@@ -112,7 +112,7 @@ public enum NativeCAPISymbol implements NativeCExtSymbol {
     FUN_OBJECT_ARRAY_RELEASE("GraalPyPrivate_ObjectArrayRelease", ArgDescriptor.Void, Pointer, Int),
     FUN_PY_OBJECT_NEW("GraalPyPrivate_ObjectNew", PyObjectTransfer, PyTypeObject),
     FUN_GRAALPY_OBJECT_GC_DEL("GraalPyPrivate_Object_GC_Del", Void, Pointer),
-    FUN_BULK_DEALLOC("GraalPyPrivate_BulkDealloc", Py_ssize_t, Pointer, INT64_T),
+    FUN_BULK_DEALLOC("GraalPyPrivate_BulkDealloc", Py_ssize_t, ArgDescriptor.UINTPTR_T, INT64_T),
     FUN_SHUTDOWN_BULK_DEALLOC("GraalPyPrivate_BulkDeallocOnShutdown", Py_ssize_t, Pointer, INT64_T),
     FUN_GET_CURRENT_RSS("GraalPyPrivate_GetCurrentRSS", SIZE_T),
     FUN_ADD_SUBOFFSET("GraalPyPrivate_AddSuboffset", Pointer, Pointer, Py_ssize_t, Py_ssize_t),

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

@@ -45,6 +45,7 @@
 
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -166,7 +167,7 @@ public HandleContext(boolean useShadowTable) {
             nativeStubLookupFreeStack.pushRange(1, DEFAULT_CAPACITY);
         }
 
-        public final NativeObjectReferenceArrayWrapper referencesToBeFreed = new NativeObjectReferenceArrayWrapper();
+        public final ArrayList<Long> referencesToBeFreed = new ArrayList<>();
         public final HashMap<Long, IdReference<?>> nativeLookup = new HashMap<>();
         public final ConcurrentHashMap<Long, Long> nativeWeakRef = new ConcurrentHashMap<>();
         public final WeakHashMap<Object, WeakReference<Object>> managedNativeLookup = new WeakHashMap<>();
@@ -417,7 +418,7 @@ public static int pollReferenceQueue() {
                 ReferenceQueue<Object> queue = handleContext.referenceQueue;
                 int count = 0;
                 long start = 0;
-                NativeObjectReferenceArrayWrapper referencesToBeFreed = handleContext.referencesToBeFreed;
+                ArrayList<Long> referencesToBeFreed = handleContext.referencesToBeFreed;
                 while (true) {
                     Object entry = queue.poll();
                     if (entry == null) {
@@ -509,7 +510,7 @@ public static int pollReferenceQueue() {
      * to be freed. Therefore, this method neither frees any native memory nor runs any object
      * destructor (guest code).
      */
-    private static void processNativeObjectReference(NativeObjectReference reference, NativeObjectReferenceArrayWrapper referencesToBeFreed) {
+    private static void processNativeObjectReference(NativeObjectReference reference, ArrayList<Long> referencesToBeFreed) {
         LOGGER.fine(() -> PythonUtils.formatJString("releasing %s", reference.toString()));
         if (subNativeRefCount(reference.pointer, MANAGED_REFCNT) == 0) {
             referencesToBeFreed.add(reference.pointer);
@@ -548,26 +549,29 @@ private static void processPyCapsuleReference(PyCapsuleReference reference) {
      * element. This method may therefore run arbitrary guest code and strictly requires the GIL to
      * be held at the time of invocation.
      */
-    private static void releaseNativeObjects(PythonContext context, NativeObjectReferenceArrayWrapper referencesToBeFreed) {
+    private static void releaseNativeObjects(PythonContext context, ArrayList<Long> referencesToBeFreed) {
         if (!referencesToBeFreed.isEmpty()) {
             /*
              * This needs the GIL because this will call the native objects' destructors which can
              * be arbitrary guest code.
              */
-            assert PythonContext.get(null).ownsGil();
+            assert context.ownsGil();
             PythonContext.PythonThreadState threadState = context.getThreadState(context.getLanguage());
             /*
              * There can be an active exception. Since we might be calling arbitary python, we need
              * to stash it.
              */
             Object savedException = CExtCommonNodes.ReadAndClearNativeException.executeUncached(threadState);
             try {
-                LOGGER.fine(() -> PythonUtils.formatJString("releasing %d NativeObjectReference instances", referencesToBeFreed.getArraySize()));
-                Object array = AllocateNode.allocUncached(referencesToBeFreed.getArraySize() * Long.BYTES);
-                CStructAccess.WriteLongNode.getUncached().writeLongArray(array, referencesToBeFreed.getArray(), (int) referencesToBeFreed.getArraySize(), 0, 0);
-                PCallCapiFunction.callUncached(NativeCAPISymbol.FUN_BULK_DEALLOC, array, referencesToBeFreed.getArraySize());
-                FreeNode.executeUncached(array);
-                referencesToBeFreed.reset();
+                int size = referencesToBeFreed.size();
+                LOGGER.fine(() -> PythonUtils.formatJString("releasing %d NativeObjectReference instances", size));
+                long pointer = AllocateNode.allocUncachedPointer(size * Long.BYTES);
+                for (int i = 0; i < size; i++) {
+                    CStructAccess.WriteLongNode.writeLong(pointer, i * Long.BYTES, referencesToBeFreed.get(i));
+                }
+                PCallCapiFunction.callUncached(NativeCAPISymbol.FUN_BULK_DEALLOC, pointer, size);
+                FreeNode.freeLong(pointer);
+                referencesToBeFreed.clear();
             } finally {
                 CExtCommonNodes.ReadAndClearNativeException.executeUncached(threadState);
                 if (savedException != PNone.NO_VALUE) {

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

@@ -131,8 +131,7 @@ static Object allocLong(long count, long size, @SuppressWarnings("unused") boole
             // non-zero size to get unique pointers
             try {
                 long totalSize = Math.multiplyExact(count, size);
-                long memory = UNSAFE.allocateMemory(totalSize == 0 ? 1 : totalSize);
-                UNSAFE.setMemory(memory, totalSize, (byte) 0);
+                long memory = allocUncachedPointer(totalSize);
                 return new NativePointer(memory);
             } catch (ArithmeticException e) {
                 overflowProfile.enter(inliningTarget);
@@ -159,6 +158,12 @@ public static Object allocUncached(long size) {
             return AllocateNodeGen.getUncached().alloc(size);
         }
 
+        public static long allocUncachedPointer(long size) {
+            long memory = UNSAFE.allocateMemory(size == 0 ? 1 : size);
+            UNSAFE.setMemory(memory, size, (byte) 0);
+            return memory;
+        }
+
         public static Object callocUncached(long count, long elSize) {
             return AllocateNodeGen.getUncached().calloc(count, elSize);
         }
@@ -179,7 +184,7 @@ public final void free(Object pointer) {
         }
 
         @Specialization
-        static void freeLong(long pointer) {
+        public static void freeLong(long pointer) {
             UNSAFE.freeMemory(pointer);
         }
 
@@ -1104,16 +1109,6 @@ public final void write(Object pointer, long value) {
             execute(pointer, 0, value);
         }
 
-        public final void writeLongArray(Object pointer, long[] values) {
-            writeLongArray(pointer, values, values.length, 0, 0);
-        }
-
-        public final void writeLongArray(Object pointer, long[] values, int length, int sourceOffset, long targetOffset) {
-            for (int i = 0; i < length; i++) {
-                execute(pointer, (i + targetOffset) * Long.BYTES, values[i + sourceOffset]);
-            }
-        }
-
         public final void writeIntArray(Object pointer, int[] values) {
             writeIntArray(pointer, values, values.length, 0, 0);
         }
@@ -1129,7 +1124,7 @@ public final boolean accepts(ArgDescriptor desc) {
         }
 
         @Specialization
-        static void writeLong(long pointer, long offset, long value) {
+        public static void writeLong(long pointer, long offset, long value) {
             assert offset >= 0;
             UNSAFE.putLong(pointer + offset, value);
         }