Merge branch 'hpy-import'

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,18 @@
+#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

@@ -158,6 +158,10 @@ 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

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

@@ -451,3 +451,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 ctx->ctx_Tracker_New ( ctx, size ); 
+}
+
+static inline int HPyTracker_Add(HPyContext ctx, HPyTracker ht, HPy h) {
+     return ctx->ctx_Tracker_Add ( ctx, ht, h ); 
+}
+
+static inline void HPyTracker_RemoveAll(HPyContext ctx, HPyTracker ht) {
+     ctx->ctx_Tracker_RemoveAll ( ctx, ht ); 
+}
+
+static inline void HPyTracker_Free(HPyContext ctx, HPyTracker ht) {
+     ctx->ctx_Tracker_Free ( ctx, 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/lib-graalpython/modules/hpy/devel/src/runtime/ctx_listbuilder.c

@@ -71,6 +71,12 @@ _HPy_HIDDEN void
 ctx_ListBuilder_Cancel(HPyContext ctx, HPyListBuilder builder)
 {
     PyObject *lst = (PyObject *)builder._lst;
+    if (lst == NULL) {
+        // we don't report the memory error here: the builder
+        // is being cancelled (so the result of the builder is not being used)
+        // and likely it's being cancelled during the handling of another error
+        return;
+    }
     builder._lst = 0;
     Py_XDECREF(lst);
 }

graalpython/lib-graalpython/modules/hpy/devel/src/runtime/ctx_module.c

@@ -1,6 +1,6 @@
 /* MIT License
  *
- * Copyright (c) 2020, 2021, Oracle and/or its affiliates.
+ * 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

graalpython/lib-graalpython/modules/hpy/devel/src/runtime/ctx_tracker.c

@@ -0,0 +1,181 @@
+/* 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.
+ */
+
+/**
+ * A manager for HPy handles, allowing handles to be tracked
+ * and closed as a group.
+ *
+ * Note::
+ *    Calling HPyTracker_New(ctx, n) will ensure that at least n handles
+ *    can be tracked without a call to HPyTracker_Add failing.
+ *
+ *    If a call to HPyTracker_Add fails, the tracker still guarantees that
+ *    the handle passed to it has been tracked (internally it does this by
+ *    maintaining space for one more handle).
+ *
+ *    After HPyTracker_Add fails, HPyTracker_Free should be called without
+ *    any further calls to HPyTracker_Add. Calling HPyTracker_Free will close
+ *    all the tracked handles, including the handled passed to the failed call
+ *    to HPyTracker_Add.
+ *
+ * Example usage (inside an HPyDef_METH function)::
+ *
+ * long i;
+ * HPy key, value;
+ * HPyTracker ht;
+ *
+ * ht = HPyTracker_New(ctx, 0);  // track the key-value pairs
+ * if (HPy_IsNull(ht))
+ *     return HPy_NULL;
+ *
+ * HPy dict = HPyDict_New(ctx);
+ * if (HPy_IsNull(dict))
+ *     goto error;
+ *
+ * for (i=0; i<5; i++) {
+ *     key = HPyLong_FromLong(ctx, i);
+ *     if (HPy_IsNull(key))
+ *         goto error;
+ *     if (HPyTracker_Add(ctx, ht, key) < 0)
+ *         goto error;
+ *     value = HPyLong_FromLong(ctx, i * i);
+ *     if (HPy_IsNull(value)) {
+ *         goto error;
+ *     }
+ *     if (HPyTracker_Add(ctx, ht, value) < 0)
+ *         goto error;
+ *     result = HPy_SetItem(ctx, dict, key, value);
+ *     if (result < 0)
+ *         goto error;
+ * }
+ *
+ * success:
+ *    HPyTracker_Free(ctx, ht);
+ *    return dict;
+ *
+ * error:
+ *    HPyTracker_Free(ctx, ht);
+ *    HPy_Close(ctx, dict);
+ *    // HPyErr will already have been set by the error that occurred.
+ *    return HPy_NULL;
+ */
+
+#include <Python.h>
+#include "hpy.h"
+#include "common/runtime/ctx_type.h"
+
+#ifdef HPY_UNIVERSAL_ABI
+#define _ht2hp(x) ((_HPyTracker_s *) (x)._i)
+#define _hp2ht(x) ((HPyTracker) {(HPy_ssize_t) (hp)})
+#else
+#define _ht2hp(x) ((_HPyTracker_s *) (x)._o)
+#define _hp2ht(x) ((HPyTracker) {(void *) (hp)})
+#endif
+
+static const HPy_ssize_t HPYTRACKER_INITIAL_SIZE = 5;
+
+typedef struct {
+    HPy_ssize_t size;
+    HPy_ssize_t next;
+    HPy *handles;
+} _HPyTracker_s;
+
+
+_HPy_HIDDEN HPyTracker
+ctx_Tracker_New(HPyContext ctx, HPy_ssize_t size)
+{
+    _HPyTracker_s *hp;
+    if (size == 0) {
+        size = HPYTRACKER_INITIAL_SIZE;
+    }
+    size++;
+
+    hp = PyMem_Malloc(sizeof(_HPyTracker_s));
+    if (hp == NULL) {
+        PyErr_NoMemory();
+        return _hp2ht(0);
+    }
+    hp->handles = PyMem_Calloc(size, sizeof(HPy));
+    if (hp->handles == NULL) {
+        PyMem_Free(hp);
+        PyErr_NoMemory();
+        return _hp2ht(0);
+    }
+    hp->size = size;
+    hp->next = 0;
+    return _hp2ht(hp);
+}
+
+static int
+tracker_resize(HPyContext ctx, _HPyTracker_s *hp, HPy_ssize_t size)
+{
+    HPy *new_handles;
+    size++;
+
+    if (size <= hp->next) {
+        // refuse a resize that would either 1) lose handles or  2) not leave
+        // space for one new handle
+        PyErr_SetString(PyExc_ValueError, "HPyTracker resize would lose handles");
+        return -1;
+    }
+    new_handles = PyMem_Realloc(hp->handles, size * sizeof(HPy));
+    if (new_handles == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    hp->size = size;
+    hp->handles = new_handles;
+    return 0;
+}
+
+_HPy_HIDDEN int
+ctx_Tracker_Add(HPyContext ctx, HPyTracker ht, HPy h)
+{
+    _HPyTracker_s *hp =  _ht2hp(ht);
+    hp->handles[hp->next++] = h;
+    if (hp->size <= hp->next) {
+        if (tracker_resize(ctx, hp, hp->size * 2 - 1) < 0)
+            return -1;
+    }
+    return 0;
+}
+
+_HPy_HIDDEN void
+ctx_Tracker_RemoveAll(HPyContext ctx, HPyTracker ht)
+{
+    _HPyTracker_s *hp = _ht2hp(ht);
+    hp->next = 0;
+}
+
+_HPy_HIDDEN void
+ctx_Tracker_Free(HPyContext ctx, HPyTracker ht)
+{
+    _HPyTracker_s *hp = _ht2hp(ht);
+    HPy_ssize_t i;
+    for (i=0; i<hp->next; i++) {
+        HPy_Close(ctx, hp->handles[i]);
+    }
+    PyMem_Free(hp->handles);
+    PyMem_Free(hp);
+}

graalpython/lib-graalpython/modules/hpy/devel/src/runtime/ctx_tuple.c

@@ -1,6 +1,6 @@
 /* MIT License
  *
- * Copyright (c) 2020, 2021, Oracle and/or its affiliates.
+ * 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