Implement cache for resolving handles.

Author: fangerer

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

@@ -53,6 +53,9 @@ uint64_t (*PY_TRUFFLE_CEXT_LANDING_L)(void* name, ...);
 double (*PY_TRUFFLE_CEXT_LANDING_D)(void* name, ...);
 void* (*PY_TRUFFLE_CEXT_LANDING_PTR)(void* name, ...);
 
+static void* cache;
+void* (*resolve_handle)(void* cache, uint64_t handle);
+
 __attribute__((constructor (__COUNTER__)))
 static void initialize_upcall_functions() {
     PY_TRUFFLE_CEXT = (void*)polyglot_import("python_cext");
@@ -70,6 +73,12 @@ static void initialize_upcall_functions() {
     Py_NoValue = UPCALL_CEXT_O(polyglot_from_string("Py_NoValue", SRC_CS));
 }
 
+__attribute__((constructor (__COUNTER__)))
+static void initialize_handle_cache() {
+    cache = polyglot_invoke(PY_TRUFFLE_CEXT, "PyTruffle_HandleCache_Create", truffle_managed_from_handle);
+    resolve_handle = ((void* (*)(void* cache, uint64_t handle))polyglot_get_member(PY_TRUFFLE_CEXT, polyglot_from_string("PyTruffle_HandleCache_GetOrInsert", SRC_CS)));
+}
+
 static void initialize_type_structure(PyTypeObject* structure, const char* typname, void* typeid) {
     PyTypeObject* ptype = (PyTypeObject*)UPCALL_CEXT_O(polyglot_from_string("PyTruffle_Type", SRC_CS), polyglot_from_string(typname, SRC_CS));
 
@@ -201,7 +210,7 @@ void* native_to_java(PyObject* obj) {
     } else if (polyglot_is_string(obj)) {
         return obj;
     } else if (truffle_is_handle_to_managed(obj)) {
-        return truffle_managed_from_handle(obj);
+        return resolve_handle(cache, (uint64_t)obj);
     } else if (truffle_is_handle_to_managed(obj->ob_refcnt)) {
         return truffle_managed_from_handle(obj->ob_refcnt);
     } else if (IS_POINTER(obj->ob_refcnt)) {
@@ -231,12 +240,12 @@ PyObject* to_sulong(void *o) {
 void* get_ob_type(PyObject* obj) {
     PyTypeObject*  type = obj->ob_type;
     if (truffle_is_handle_to_managed(type)) {
-        return truffle_managed_from_handle(type);
+        return resolve_handle(cache, (uint64_t)type);
     } else {
         // we have stored a handle to the Java class in ob_refcnt
         void* handle = (void*)((PyObject*)type)->ob_refcnt;
         if (truffle_is_handle_to_managed(handle)) {
-            return truffle_managed_from_handle(handle);
+            return resolve_handle(cache, (uint64_t)handle);
         } else {
             // assume handle is a TruffleObject
             return handle;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/TruffleCextBuiltins.java

@@ -116,6 +116,7 @@
 import com.oracle.graal.python.nodes.expression.BinaryComparisonNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinNode;
+import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonUnaryBuiltinNode;
 import com.oracle.graal.python.nodes.interop.PForeignToPTypeNode;
 import com.oracle.graal.python.nodes.object.GetClassNode;
@@ -149,6 +150,7 @@
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.interop.UnsupportedTypeException;
 import com.oracle.truffle.api.nodes.DirectCallNode;
+import com.oracle.truffle.api.nodes.ExplodeLoop;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
 import com.oracle.truffle.api.profiles.BranchProfile;
@@ -1841,4 +1843,88 @@ Object doIt(Object object,
             return wrapper;
         }
     }
+
+    private static class HandleCacheEntry {
+        private long key;
+        private Object value;
+    }
+
+    static class HandleCache implements TruffleObject {
+        private static final int CACHE_SIZE = 10;
+
+        private final HandleCacheEntry[] entries;
+        private final TruffleObject ptrToResolveHandle;
+
+        private int pos = 0;
+
+        public HandleCache(TruffleObject ptrToResolveHandle) {
+            entries = new HandleCacheEntry[CACHE_SIZE];
+            for (int i = 0; i < entries.length; i++) {
+                entries[i] = new HandleCacheEntry();
+            }
+            this.ptrToResolveHandle = ptrToResolveHandle;
+        }
+
+        protected int len() {
+            return entries.length;
+        }
+
+        protected TruffleObject getPtrToResolveHandle() {
+            return ptrToResolveHandle;
+        }
+
+        public ForeignAccess getForeignAccess() {
+            return null;
+        }
+    }
+
+    @Builtin(name = "PyTruffle_HandleCache_Create", fixedNumOfPositionalArgs = 1)
+    @GenerateNodeFactory
+    abstract static class PyTruffleHandleCacheCreate extends PythonUnaryBuiltinNode {
+        @Specialization
+        Object createCache(TruffleObject ptrToResolveHandle) {
+            return new HandleCache(ptrToResolveHandle);
+        }
+    }
+
+    @Builtin(name = "PyTruffle_HandleCache_GetOrInsert", fixedNumOfPositionalArgs = 2)
+    @GenerateNodeFactory
+    abstract static class PyTruffleHandleCacheGetOrInsert extends PythonBinaryBuiltinNode {
+        @Child private Node executeNode;
+
+        private final BranchProfile errorProfile = BranchProfile.create();
+
+        @ExplodeLoop
+        @Specialization(limit = "1", guards = {"cache.len() == cachedLen", "cache.getPtrToResolveHandle() == ptrToResolveHandle"})
+        Object doIt(HandleCache cache, long handle,
+                        @Cached("cache.len()") int cachedLen,
+                        @Cached("cache.getPtrToResolveHandle()") TruffleObject ptrToResolveHandle) {
+            for (int i = 0; i < cachedLen; i++) {
+                if (cache.entries[i].key == handle) {
+                    return cache.entries[i].value;
+                }
+            }
+
+            try {
+                Object resolved = ForeignAccess.sendExecute(getExecuteNode(), ptrToResolveHandle, handle);
+
+                cache.entries[cache.pos].key = handle;
+                cache.entries[cache.pos].value = resolved;
+                cache.pos = (cache.pos + 1) % cache.len();
+
+                return resolved;
+            } catch (UnsupportedTypeException | ArityException | UnsupportedMessageException e) {
+                errorProfile.enter();
+                throw e.raise();
+            }
+        }
+
+        private Node getExecuteNode() {
+            if (executeNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                executeNode = insert(Message.EXECUTE.createNode());
+            }
+            return executeNode;
+        }
+    }
 }