[GR-29191] Update HPy Import.

PullRequest: graalpython/1594

Author: fangerer

graalpython/com.oracle.graal.python.cext/include/common/hpydef.h

@@ -150,7 +150,7 @@ typedef struct {
     };
 
 
-#define HPyDef_METH(SYM, NAME, IMPL, SIG)                               \
+#define HPyDef_METH(SYM, NAME, IMPL, SIG, ...)                          \
     HPyFunc_DECLARE(IMPL, SIG);                                         \
     HPyFunc_TRAMPOLINE(SYM##_trampoline, IMPL, SIG);                    \
     HPyDef SYM = {                                                      \
@@ -159,7 +159,8 @@ typedef struct {
             .name = NAME,                                               \
             .impl = IMPL,                                               \
             .cpy_trampoline = SYM##_trampoline,                         \
-            .signature = SIG                                            \
+            .signature = SIG,                                           \
+            __VA_ARGS__                                                 \
         }                                                               \
     };
 

graalpython/com.oracle.graal.python.cext/include/common/runtime/ctx_tracker.h

@@ -0,0 +1,42 @@
+/* MIT License
+ *
+ * Copyright (c) 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2019 pyhandle
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall 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.
+ */
+
+#ifndef HPY_COMMON_RUNTIME_CTX_TRACKER_H
+#define HPY_COMMON_RUNTIME_CTX_TRACKER_H
+
+#include "hpy.h"
+
+_HPy_HIDDEN HPyTracker
+ctx_Tracker_New(HPyContext ctx, HPy_ssize_t size);
+
+_HPy_HIDDEN int
+ctx_Tracker_Add(HPyContext ctx, HPyTracker ht, HPy h);
+
+_HPy_HIDDEN void
+ctx_Tracker_RemoveAll(HPyContext ctx, HPyTracker ht);
+
+_HPy_HIDDEN void
+ctx_Tracker_Free(HPyContext ctx, HPyTracker ht);
+
+#endif /* HPY_COMMON_RUNTIME_CTX_TRACKER_H */

graalpython/com.oracle.graal.python.cext/include/cpython/hpy.h

@@ -56,6 +56,7 @@
 typedef struct { PyObject *_o; } HPy;
 typedef struct { Py_ssize_t _lst; } HPyListBuilder;
 typedef struct { Py_ssize_t _tup; } HPyTupleBuilder;
+typedef struct { void *_o; } HPyTracker;
 typedef Py_ssize_t HPy_ssize_t;
 typedef Py_hash_t HPy_hash_t;
 
@@ -165,6 +166,7 @@ HPy_AsPyObject(HPyContext ctx, HPy h)
 #include "../common/runtime/ctx_module.h"
 #include "../common/runtime/ctx_type.h"
 #include "../common/runtime/ctx_listbuilder.h"
+#include "../common/runtime/ctx_tracker.h"
 #include "../common/runtime/ctx_tuple.h"
 #include "../common/runtime/ctx_tuplebuilder.h"
 
@@ -260,4 +262,28 @@ HPyTuple_FromArray(HPyContext ctx, HPy items[], HPy_ssize_t n)
     return ctx_Tuple_FromArray(ctx, items, n);
 }
 
+HPyAPI_FUNC(HPyTracker)
+HPyTracker_New(HPyContext ctx, HPy_ssize_t size)
+{
+    return ctx_Tracker_New(ctx, size);
+}
+
+HPyAPI_FUNC(int)
+HPyTracker_Add(HPyContext ctx, HPyTracker ht, HPy h)
+{
+    return ctx_Tracker_Add(ctx, ht, h);
+}
+
+HPyAPI_FUNC(void)
+HPyTracker_RemoveAll(HPyContext ctx, HPyTracker ht)
+{
+    ctx_Tracker_RemoveAll(ctx, ht);
+}
+
+HPyAPI_FUNC(void)
+HPyTracker_Free(HPyContext ctx, HPyTracker ht)
+{
+    ctx_Tracker_Free(ctx, ht);
+}
+
 #endif /* !HPy_CPYTHON_H */

graalpython/com.oracle.graal.python.cext/include/universal/autogen_ctx.h

@@ -38,6 +38,7 @@ typedef HPy _HPyConst;
 #define HPy void*
 #define HPyListBuilder void*
 #define HPyTupleBuilder void*
+#define HPyTracker void*
 
 
 struct _HPyContext_s {
@@ -158,8 +159,13 @@ struct _HPyContext_s {
     void (*ctx_TupleBuilder_Set)(HPyContext ctx, HPyTupleBuilder builder, HPy_ssize_t index, HPy h_item);
     HPy (*ctx_TupleBuilder_Build)(HPyContext ctx, HPyTupleBuilder builder);
     void (*ctx_TupleBuilder_Cancel)(HPyContext ctx, HPyTupleBuilder builder);
+    HPyTracker (*ctx_Tracker_New)(HPyContext ctx, HPy_ssize_t size);
+    int (*ctx_Tracker_Add)(HPyContext ctx, HPyTracker ht, HPy h);
+    void (*ctx_Tracker_RemoveAll)(HPyContext ctx, HPyTracker ht);
+    void (*ctx_Tracker_Free)(HPyContext ctx, HPyTracker ht);
 };
 
 #undef HPy
 #undef HPyListBuilder
 #undef HPyTupleBuilder
+#undef HPyTracker

graalpython/com.oracle.graal.python.cext/include/universal/autogen_trampolines.h

@@ -38,6 +38,8 @@
 #define WRAP_TUPLE_BUILDER(_ptr) ((HPyTupleBuilder){(_ptr)})
 #define UNWRAP_LIST_BUILDER(_h) ((_h)._lst)
 #define WRAP_LIST_BUILDER(_ptr) ((HPyListBuilder){(_ptr)})
+#define UNWRAP_TRACKER(_h) ((_h)._i)
+#define WRAP_TRACKER(_ptr) ((HPyTracker){(_ptr)})
 
 static inline HPy HPyModule_Create(HPyContext ctx, HPyModuleDef *def) {
      return WRAP(ctx->ctx_Module_Create ( ctx, def ));
@@ -451,3 +453,19 @@ static inline void HPyTupleBuilder_Cancel(HPyContext ctx, HPyTupleBuilder builde
      ctx->ctx_TupleBuilder_Cancel ( ctx, UNWRAP_TUPLE_BUILDER(builder));
 }
 
+static inline HPyTracker HPyTracker_New(HPyContext ctx, HPy_ssize_t size) {
+     return WRAP_TRACKER(ctx->ctx_Tracker_New ( ctx, size )); 
+}
+
+static inline int HPyTracker_Add(HPyContext ctx, HPyTracker ht, HPy h) {
+     return ctx->ctx_Tracker_Add ( ctx, UNWRAP_TRACKER(ht), UNWRAP(h) ); 
+}
+
+static inline void HPyTracker_RemoveAll(HPyContext ctx, HPyTracker ht) {
+     ctx->ctx_Tracker_RemoveAll ( ctx, UNWRAP_TRACKER(ht) ); 
+}
+
+static inline void HPyTracker_Free(HPyContext ctx, HPyTracker ht) {
+     ctx->ctx_Tracker_Free ( ctx, UNWRAP_TRACKER(ht) ); 
+}
+

graalpython/com.oracle.graal.python.cext/include/universal/hpy.h

@@ -59,6 +59,7 @@ typedef intptr_t HPy_hash_t;
 typedef struct _HPy_s { void* _i; } HPy;
 typedef struct { void* _lst; } HPyListBuilder;
 typedef struct { void* _tup; } HPyTupleBuilder;
+typedef struct { void* _i; } HPyTracker;
 
 typedef struct _HPyContext_s *HPyContext;
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/hpy/GraalHPyContext.java

@@ -108,6 +108,9 @@
 import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPySetAttr;
 import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPySetItem;
 import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPyTernaryArithmetic;
+import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPyTrackerAdd;
+import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPyTrackerCleanup;
+import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPyTrackerNew;
 import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPyTupleFromArray;
 import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPyTypeFromSpec;
 import com.oracle.graal.python.builtins.objects.cext.hpy.GraalHPyContextFunctions.GraalHPyTypeGenericNew;
@@ -289,19 +292,19 @@ enum HPyContextMembers {
         CTX_LIST_BUILDER_NEW("ctx_ListBuilder_New"),
         CTX_LIST_BUILDER_SET("ctx_ListBuilder_Set"),
         CTX_LIST_BUILDER_BUILD("ctx_ListBuilder_Build"),
-        CTX_LIST_BUILDER_CANCEL("ctx_ListBuilder_Cancel");
+        CTX_LIST_BUILDER_CANCEL("ctx_ListBuilder_Cancel"),
+        CTX_TRACKER_NEW("ctx_Tracker_New"),
+        CTX_TRACKER_ADD("ctx_Tracker_Add"),
+        CTX_TRACKER_REMOVE_ALL("ctx_Tracker_RemoveAll"),
+        CTX_TRACKER_FREE("ctx_Tracker_Free");
 
         private final String name;
 
         HPyContextMembers(String name) {
             this.name = name;
         }
 
-        @CompilationFinal(dimensions = 1) private static final HPyContextMembers[] VALUES;
-        static {
-            HPyContextMembers[] members = values();
-            VALUES = Arrays.copyOf(members, members.length);
-        }
+        @CompilationFinal(dimensions = 1) private static final HPyContextMembers[] VALUES = values();
 
         @ExplodeLoop(kind = LoopExplosionKind.FULL_UNROLL_UNTIL_RETURN)
         public static HPyContextMembers getByName(String name) {
@@ -751,6 +754,11 @@ private static Object[] createMembers(PythonContext context) {
         members[HPyContextMembers.CTX_LIST_BUILDER_SET.ordinal()] = graalHPyBuilderSet;
         members[HPyContextMembers.CTX_LIST_BUILDER_BUILD.ordinal()] = new GraalHPyBuilderBuild(PList);
         members[HPyContextMembers.CTX_LIST_BUILDER_CANCEL.ordinal()] = graalHPyBuilderCancel;
+
+        members[HPyContextMembers.CTX_TRACKER_NEW.ordinal()] = new GraalHPyTrackerNew();
+        members[HPyContextMembers.CTX_TRACKER_ADD.ordinal()] = new GraalHPyTrackerAdd();
+        members[HPyContextMembers.CTX_TRACKER_REMOVE_ALL.ordinal()] = new GraalHPyTrackerCleanup(true);
+        members[HPyContextMembers.CTX_TRACKER_FREE.ordinal()] = new GraalHPyTrackerCleanup(false);
         return members;
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/hpy/GraalHPyContextFunctions.java

@@ -134,6 +134,7 @@
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
 import com.oracle.graal.python.runtime.sequence.PSequence;
 import com.oracle.graal.python.runtime.sequence.storage.ObjectSequenceStorage;
+import com.oracle.graal.python.util.OverflowException;
 import com.oracle.graal.python.util.PythonUtils;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -1598,11 +1599,11 @@ Object execute(Object[] arguments,
         }
     }
 
-    @ExportLibrary(InteropLibrary.class)
-    public static final class GraalHPyBuilderNew extends GraalHPyContextFunction {
+    abstract static class GraalHPyBuilderNewBase extends GraalHPyContextFunction {
 
-        @ExportMessage
-        Object execute(Object[] arguments,
+        protected abstract Object createObject(int capacity);
+
+        protected final Object doExecute(Object[] arguments,
                         @Cached HPyAsContextNode asContextNode,
                         @Cached CastToJavaIntExactNode castToJavaIntExactNode,
                         @Cached HPyAsHandleNode asHandleNode) throws ArityException {
@@ -1614,11 +1615,7 @@ Object execute(Object[] arguments,
             try {
                 int capacity = castToJavaIntExactNode.execute(arguments[1]);
                 if (capacity >= 0) {
-                    Object[] data = new Object[capacity];
-                    for (int i = 0; i < data.length; i++) {
-                        data[i] = PNone.NONE;
-                    }
-                    return asHandleNode.execute(nativeContext, new ObjectSequenceStorage(data));
+                    return asHandleNode.execute(nativeContext, createObject(capacity));
                 }
             } catch (CannotCastException e) {
                 // fall through
@@ -1627,6 +1624,26 @@ Object execute(Object[] arguments,
         }
     }
 
+    @ExportLibrary(InteropLibrary.class)
+    public static final class GraalHPyBuilderNew extends GraalHPyBuilderNewBase {
+        @ExportMessage
+        Object execute(Object[] arguments,
+                        @Cached HPyAsContextNode asContextNode,
+                        @Cached CastToJavaIntExactNode castToJavaIntExactNode,
+                        @Cached HPyAsHandleNode asHandleNode) throws ArityException {
+            return doExecute(arguments, asContextNode, castToJavaIntExactNode, asHandleNode);
+        }
+
+        @Override
+        protected Object createObject(int capacity) {
+            Object[] data = new Object[capacity];
+            for (int i = 0; i < data.length; i++) {
+                data[i] = PNone.NONE;
+            }
+            return new ObjectSequenceStorage(data);
+        }
+    }
+
     @ExportLibrary(InteropLibrary.class)
     public static final class GraalHPyBuilderSet extends GraalHPyContextFunction {
 
@@ -1759,4 +1776,94 @@ private static ObjectSequenceStorage cast(Object object) {
 
     }
 
+    @ExportLibrary(InteropLibrary.class)
+    public static final class GraalHPyTrackerNew extends GraalHPyBuilderNewBase {
+        @ExportMessage
+        Object execute(Object[] arguments,
+                        @Cached HPyAsContextNode asContextNode,
+                        @Cached CastToJavaIntExactNode castToJavaIntExactNode,
+                        @Cached HPyAsHandleNode asHandleNode) throws ArityException {
+            return doExecute(arguments, asContextNode, castToJavaIntExactNode, asHandleNode);
+        }
+
+        @Override
+        protected Object createObject(int capacity) {
+            return new GraalHPyTracker(capacity);
+        }
+    }
+
+    @ExportLibrary(InteropLibrary.class)
+    public static final class GraalHPyTrackerAdd extends GraalHPyContextFunction {
+        @ExportMessage
+        Object execute(Object[] arguments,
+                        @Cached HPyAsContextNode asContextNode,
+                        @Cached HPyAsPythonObjectNode asPythonObjectNode,
+                        @Cached HPyEnsureHandleNode ensureHandleNode) throws ArityException, UnsupportedTypeException {
+            if (arguments.length != 3) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                throw ArityException.create(2, arguments.length);
+            }
+            GraalHPyContext nativeContext = asContextNode.execute(arguments[0]);
+            GraalHPyTracker builder = cast(asPythonObjectNode.execute(nativeContext, arguments[1]));
+            if (builder == null) {
+                // that's really unexpected since the C signature should enforce a valid builder but
+                // someone could have messed it up
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                throw UnsupportedTypeException.create(arguments, "invalid builder object");
+            }
+            try {
+                builder.add(ensureHandleNode.execute(nativeContext, arguments[2]));
+            } catch (OverflowException | OutOfMemoryError e) {
+                return -1;
+            }
+            return 0;
+        }
+
+        private static GraalHPyTracker cast(Object object) {
+            if (object instanceof GraalHPyTracker) {
+                return (GraalHPyTracker) object;
+            }
+            return null;
+        }
+    }
+
+    @ExportLibrary(InteropLibrary.class)
+    public static final class GraalHPyTrackerCleanup extends GraalHPyContextFunction {
+        private final boolean removeAll;
+
+        public GraalHPyTrackerCleanup(boolean removeAll) {
+            this.removeAll = removeAll;
+        }
+
+        @ExportMessage
+        Object execute(Object[] arguments,
+                        @Cached HPyAsContextNode asContextNode,
+                        @Cached HPyAsPythonObjectNode asPythonObjectNode) throws ArityException, UnsupportedTypeException {
+            if (arguments.length != 2) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                throw ArityException.create(2, arguments.length);
+            }
+            GraalHPyContext nativeContext = asContextNode.execute(arguments[0]);
+            GraalHPyTracker builder = cast(asPythonObjectNode.execute(nativeContext, arguments[1]));
+            if (builder == null) {
+                // that's really unexpected since the C signature should enforce a valid builder but
+                // someone could have messed it up
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                throw UnsupportedTypeException.create(arguments, "invalid builder object");
+            }
+            if (removeAll) {
+                builder.removeAll();
+            } else {
+                builder.free(nativeContext, ConditionProfile.getUncached());
+            }
+            return 0;
+        }
+
+        private static GraalHPyTracker cast(Object object) {
+            if (object instanceof GraalHPyTracker) {
+                return (GraalHPyTracker) object;
+            }
+            return null;
+        }
+    }
 }