avoid tracking unboxed+immutable handles, bulk close trackers

Author: timfel

graalpython/com.oracle.graal.python.jni/src/ctx_tracker.c

@@ -81,7 +81,7 @@
  *    return HPy_NULL;
  */
 
-#include "hpy.h"
+#include "hpy_jni.h"
 
 static const HPy_ssize_t HPYTRACKER_INITIAL_CAPACITY = 5;
 
@@ -155,13 +155,20 @@ tracker_resize(HPyContext *ctx, _HPyTracker_s *hp, HPy_ssize_t capacity)
 _HPy_HIDDEN int
 ctx_Tracker_Add(HPyContext *ctx, HPyTracker ht, HPy h)
 {
-    _HPyTracker_s *hp =  _ht2hp(ht);
-    hp->handles[hp->length++] = h;
-    if (hp->capacity <= hp->length) {
-        if (tracker_resize(ctx, hp, hp->capacity * 2 - 1) < 0)
-            return -1;
+    uint64_t bits = toBits(h);
+    if (!isBoxedHandle(bits)) {
+        return 0;
+    } else if (bits < IMMUTABLE_HANDLES) {
+        return 0;
+    } else {
+        _HPyTracker_s *hp =  _ht2hp(ht);
+        hp->handles[hp->length++] = h;
+        if (hp->capacity <= hp->length) {
+            if (tracker_resize(ctx, hp, hp->capacity * 2 - 1) < 0)
+                return -1;
+        }
+        return 0;
     }
-    return 0;
 }
 
 _HPy_HIDDEN void
@@ -176,9 +183,7 @@ ctx_Tracker_Close(HPyContext *ctx, HPyTracker ht)
 {
     _HPyTracker_s *hp = _ht2hp(ht);
     HPy_ssize_t i;
-    for (i=0; i<hp->length; i++) {
-        HPy_Close(ctx, hp->handles[i]);
-    }
+    upcallBulkClose(ctx, hp->handles, hp->length);
     free(hp->handles);
     free(hp);
 }

graalpython/com.oracle.graal.python.jni/src/hpy_jni.c

@@ -198,25 +198,6 @@ static HPy ctx_ListNew_jni(HPyContext *ctx, HPy_ssize_t len) {
 //*************************
 // BOXING
 
-#define NAN_BOXING_BASE (0x0007000000000000llu)
-#define NAN_BOXING_MASK (0xFFFF000000000000llu)
-#define NAN_BOXING_INT (0x0001000000000000llu)
-#define NAN_BOXING_INT_MASK (0x00000000FFFFFFFFllu)
-#define NAN_BOXING_MAX_HANDLE (0x000000007FFFFFFFllu)
-#define IMMUTABLE_HANDLES (0x0000000000000100llu)
-
-static bool isBoxedDouble(uint64_t value) {
-    return value >= NAN_BOXING_BASE;
-}
-
-static bool isBoxedHandle(uint64_t value) {
-    return value <= NAN_BOXING_MAX_HANDLE;
-}
-
-static bool isBoxedInt(uint64_t value) {
-    return (value & NAN_BOXING_MASK) == NAN_BOXING_INT;
-}
-
 static double unboxDouble(uint64_t value) {
     uint64_t doubleBits = value - NAN_BOXING_BASE;
     return * ((double*) &doubleBits);
@@ -228,32 +209,6 @@ static uint64_t boxDouble(double value) {
     return doubleBits + NAN_BOXING_BASE;
 }
 
-static uint64_t unboxHandle(uint64_t value) {
-    return value;
-}
-
-static uint64_t boxHandle(uint64_t handle) {
-    return handle;
-}
-
-static int32_t unboxInt(uint64_t value) {
-    return (int32_t) (value - NAN_BOXING_INT);
-}
-
-static uint64_t boxInt(int32_t value) {
-    return (value & NAN_BOXING_INT_MASK) + NAN_BOXING_INT;
-}
-
-static inline uint64_t toBits(HPy ptr) {
-    /* return * ((uint64_t*) &ptr._i); */
-    return (uint64_t) (ptr._i);
-}
-
-static inline HPy toPtr(uint64_t ptr) {
-    /* return * ((void**) &ptr); */
-    return (HPy) { (HPy_ssize_t) ptr };
-}
-
 //*************************
 // direct fast paths that handle certain calls on the native side:
 
@@ -325,7 +280,7 @@ static HPy augment_LongFromLong(HPyContext *ctx, long l) {
 
 #define MAX_UNCLOSED_HANDLES 32
 static int32_t unclosedHandleTop = 0;
-static uint64_t unclosedHandles[MAX_UNCLOSED_HANDLES] = { 0 };
+static HPy unclosedHandles[MAX_UNCLOSED_HANDLES];
 
 static void augment_Close(HPyContext *ctx, HPy h) {
     uint64_t bits = toBits(h);
@@ -336,9 +291,9 @@ static void augment_Close(HPyContext *ctx, HPy h) {
             return;
         }
         if (unclosedHandleTop < MAX_UNCLOSED_HANDLES) {
-            unclosedHandles[unclosedHandleTop++] = bits;
+            unclosedHandles[unclosedHandleTop++] = h;
         } else {
-            DO_UPCALL_VOID(CONTEXT_INSTANCE(ctx), BulkClose, unclosedHandles, unclosedHandleTop);
+            upcallBulkClose(ctx, unclosedHandles, unclosedHandleTop);
             memset(unclosedHandles, 0, sizeof(uint64_t) * unclosedHandleTop);
             unclosedHandleTop = 0;
         }
@@ -454,6 +409,9 @@ static HPy augment_TupleFromArray(HPyContext *ctx, HPy *items, HPy_ssize_t nitem
     return upcallTupleFromArray(ctx, items, nitems, JNI_FALSE);
 }
 
+_HPy_HIDDEN void upcallBulkClose(HPyContext *ctx, HPy *items, HPy_ssize_t nitems) {
+    DO_UPCALL_VOID(CONTEXT_INSTANCE(ctx), BulkClose, items, nitems);
+}
 
 void initDirectFastPaths(HPyContext *context) {
     LOG("%p", context);

graalpython/com.oracle.graal.python.jni/src/hpy_jni.h

@@ -48,4 +48,29 @@
 #include <hpy.h>
 #include <jni.h>
 
+//*************************
+// BOXING
+
+#define NAN_BOXING_BASE (0x0007000000000000llu)
+#define NAN_BOXING_MASK (0xFFFF000000000000llu)
+#define NAN_BOXING_INT (0x0001000000000000llu)
+#define NAN_BOXING_INT_MASK (0x00000000FFFFFFFFllu)
+#define NAN_BOXING_MAX_HANDLE (0x000000007FFFFFFFllu)
+#define IMMUTABLE_HANDLES (0x0000000000000100llu)
+
+#define isBoxedDouble(value) ((value) >= NAN_BOXING_BASE)
+#define isBoxedHandle(value) ((value) <= NAN_BOXING_MAX_HANDLE)
+#define isBoxedInt(value) (((value) & NAN_BOXING_MASK) == NAN_BOXING_INT)
+
+#define unboxHandle(value) (value)
+#define boxHandle(handle) (handle)
+
+#define unboxInt(value) ((int32_t) ((value) - NAN_BOXING_INT))
+#define boxInt(value) ((((uint64_t) (value)) & NAN_BOXING_INT_MASK) + NAN_BOXING_INT)
+
+#define toBits(ptr) ((uint64_t) ((ptr)._i))
+#define toPtr(ptr) ((HPy) { (HPy_ssize_t) (ptr) })
+
 _HPy_HIDDEN HPy upcallTupleFromArray(HPyContext *ctx, HPy *items, HPy_ssize_t nitems, jboolean steal);
+
+_HPy_HIDDEN void upcallBulkClose(HPyContext *ctx, HPy *items, HPy_ssize_t nitems);