[GR-52150] Python GC.

PullRequest: graalpython/3304

Author: fangerer

graalpython/com.oracle.graal.python.cext/CMakeLists.txt

@@ -60,10 +60,11 @@ set(TARGET_LIBPYTHON "python-${LLVM_MODE}")
 # common variables and compile/link options (for all build targets)
 ######################################################################
 
-set(CFLAGS_WARNINGS -Wall -Werror -Wno-unused-function -Wno-unused-variable -Wno-unused-const-variable
+set(CFLAGS_WARNINGS -Wall -Werror,-Wunknown-warning-option -Wno-unused-function -Wno-unused-variable -Wno-unused-const-variable
                     -Wno-tautological-constant-out-of-range-compare   # fileutils.c: wchar_t > MAX_UNICODE is always false on Windows
                     -Wno-unused-but-set-variable                      # sqlite.c: BOOL bRc
                     -Wno-ignored-pragmas                              # sre.c: #pragma optimize("agtw", on)
+                    -Wno-discarded-qualifiers                         # longobject.c: *pend = str; (gcc only hence: '-Wunknown-warning-option')
                     -Wno-int-to-pointer-cast -Wno-int-conversion -Wno-void-pointer-to-int-cast
                     -Wno-incompatible-pointer-types-discards-qualifiers -Wno-pointer-type-mismatch
                     -Wno-braced-scalar-init -Wno-deprecated-declarations)

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

@@ -206,12 +206,16 @@ struct _ts {
     /* The bottom-most frame on the stack. */
     _PyCFrame root_cframe;
 
-    /* GraalVM change: We add field 'small_ints' which roughly corresponds to
+    /* GraalPy change: We add field 'small_ints' which roughly corresponds to
        field '_PyRuntimeState._Py_global_objects.small_ints'. We do so because
        we maintain the runtime state in Java objects and don't want to allocate
        the large structures and arrays where for us, most fields will be zero.
     */
     PyObject **small_ints;
+
+    /* GraalPy change: We add field 'gc' which corresponds to field
+       '&interp->gc'. */
+    struct _gc_runtime_state *gc;
 };
 
 

graalpython/com.oracle.graal.python.cext/include/internal/pycore_gc.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+/* Copyright (c) 2022, 2024, Oracle and/or its affiliates.
  * Copyright (C) 1996-2022 Python Software Foundation
  *
  * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
@@ -27,8 +27,11 @@ typedef struct {
 #define _Py_AS_GC(o) ((PyGC_Head *)(o)-1)
 #define _PyGC_Head_UNUSED PyGC_Head
 
+// GraalPy change
+#define _PyGCHead_UNTAG(PTR) ((PyGC_Head *)(((uintptr_t) (PTR)) & ~HANDLE_BASE))
+
 /* True if the object is currently tracked by the GC. */
-#define _PyObject_GC_IS_TRACKED(o) (_Py_AS_GC(o)->_gc_next != 0)
+#define _PyObject_GC_IS_TRACKED(o) (_PyGCHead_UNTAG(_Py_AS_GC(o))->_gc_next != 0)
 
 /* True if the object may be tracked by the GC in the future, or already is.
    This can be useful to implement some optimizations. */
@@ -48,21 +51,21 @@ typedef struct {
 
 // Lowest bit of _gc_next is used for flags only in GC.
 // But it is always 0 for normal code.
-#define _PyGCHead_NEXT(g)        ((PyGC_Head*)(g)->_gc_next)
-#define _PyGCHead_SET_NEXT(g, p) _Py_RVALUE((g)->_gc_next = (uintptr_t)(p))
+#define _PyGCHead_NEXT(g)        ((PyGC_Head*)_PyGCHead_UNTAG(g)->_gc_next)
+#define _PyGCHead_SET_NEXT(g, p) _Py_RVALUE(_PyGCHead_UNTAG(g)->_gc_next = (uintptr_t)(p))
 
 // Lowest two bits of _gc_prev is used for _PyGC_PREV_MASK_* flags.
-#define _PyGCHead_PREV(g) ((PyGC_Head*)((g)->_gc_prev & _PyGC_PREV_MASK))
+#define _PyGCHead_PREV(g) ((PyGC_Head*)(_PyGCHead_UNTAG(g)->_gc_prev & _PyGC_PREV_MASK))
 #define _PyGCHead_SET_PREV(g, p) do { \
     assert(((uintptr_t)p & ~_PyGC_PREV_MASK) == 0); \
-    (g)->_gc_prev = ((g)->_gc_prev & ~_PyGC_PREV_MASK) \
+    _PyGCHead_UNTAG(g)->_gc_prev = (_PyGCHead_UNTAG(g)->_gc_prev & ~_PyGC_PREV_MASK) \
         | ((uintptr_t)(p)); \
     } while (0)
 
 #define _PyGCHead_FINALIZED(g) \
-    (((g)->_gc_prev & _PyGC_PREV_MASK_FINALIZED) != 0)
+    ((_PyGCHead_UNTAG(g)->_gc_prev & _PyGC_PREV_MASK_FINALIZED) != 0)
 #define _PyGCHead_SET_FINALIZED(g) \
-    _Py_RVALUE((g)->_gc_prev |= _PyGC_PREV_MASK_FINALIZED)
+    _Py_RVALUE(_PyGCHead_UNTAG(g)->_gc_prev |= _PyGC_PREV_MASK_FINALIZED)
 
 #define _PyGC_FINALIZED(o) \
     _PyGCHead_FINALIZED(_Py_AS_GC(o))

graalpython/com.oracle.graal.python.cext/include/internal/pycore_object.h

@@ -14,10 +14,14 @@ extern "C" {
 #endif
 
 #include <stdbool.h>
-// #include "pycore_gc.h"            // _PyObject_GC_IS_TRACKED()
-// #include "pycore_interp.h"        // PyInterpreterState.gc
-// #include "pycore_pystate.h"       // _PyInterpreterState_GET()
-// #include "pycore_runtime.h"       // _PyRuntime
+#include "pycore_gc.h"            // _PyObject_GC_IS_TRACKED()
+#if 0 // GraalPy change
+#include "pycore_interp.h"        // PyInterpreterState.gc
+#endif
+#include "pycore_pystate.h"       // _PyInterpreterState_GET()
+#if 0 // GraalPy change
+#include "pycore_runtime.h"       // _PyRuntime
+#endif
 
 #define _PyObject_IMMORTAL_INIT(type) \
     { \
@@ -134,8 +138,28 @@ static inline void _PyObject_GC_TRACK(
 #endif
     PyObject *op)
 {
-    // GraalPy change
-    PyObject_GC_Track(op);
+    _PyObject_ASSERT_FROM(op, !_PyObject_GC_IS_TRACKED(op),
+                          "object already tracked by the garbage collector",
+                          filename, lineno, __func__);
+
+    PyGC_Head *gc = _Py_AS_GC(op);
+    _PyObject_ASSERT_FROM(op,
+                          (gc->_gc_prev & _PyGC_PREV_MASK_COLLECTING) == 0,
+                          "object is in generation which is garbage collected",
+                          filename, lineno, __func__);
+
+#if 0 // GraalPy change
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+    PyGC_Head *generation0 = interp->gc.generation0;
+#else // GraalPy change
+    PyThreadState *tstate = _PyThreadState_GET();
+    PyGC_Head *generation0 = tstate->gc->generation0;
+#endif // GraalPy change
+    PyGC_Head *last = (PyGC_Head*)(generation0->_gc_prev);
+    _PyGCHead_SET_NEXT(last, gc);
+    _PyGCHead_SET_PREV(gc, last);
+    _PyGCHead_SET_NEXT(gc, generation0);
+    generation0->_gc_prev = (uintptr_t)gc;
 }
 
 /* Tell the GC to stop tracking this object.
@@ -155,13 +179,26 @@ static inline void _PyObject_GC_UNTRACK(
 #endif
     PyObject *op)
 {
-    // GraalPy change
-    PyObject_GC_UnTrack(op);
+    _PyObject_ASSERT_FROM(op, _PyObject_GC_IS_TRACKED(op),
+                          "object not tracked by the garbage collector",
+                          filename, lineno, __func__);
+
+    PyGC_Head *gc = _Py_AS_GC(op);
+    PyGC_Head *prev = _PyGCHead_PREV(gc);
+    PyGC_Head *next = _PyGCHead_NEXT(gc);
+    _PyGCHead_SET_NEXT(prev, next);
+    _PyGCHead_SET_PREV(next, prev);
+    _PyGCHead_UNTAG(gc)->_gc_next = 0;
+    _PyGCHead_UNTAG(gc)->_gc_prev &= _PyGC_PREV_MASK_FINALIZED;
 }
 
 // Macros to accept any type for the parameter, and to automatically pass
 // the filename and the filename (if NDEBUG is not defined) where the macro
 // is called.
+#ifdef GRAALVM_PYTHON_LLVM_MANAGED
+#  define _PyObject_GC_TRACK(op)
+#  define _PyObject_GC_UNTRACK(op)
+#else
 #ifdef NDEBUG
 #  define _PyObject_GC_TRACK(op) \
         _PyObject_GC_TRACK(_PyObject_CAST(op))
@@ -173,6 +210,7 @@ static inline void _PyObject_GC_UNTRACK(
 #  define _PyObject_GC_UNTRACK(op) \
         _PyObject_GC_UNTRACK(__FILE__, __LINE__, _PyObject_CAST(op))
 #endif
+#endif
 
 #ifdef Py_REF_DEBUG
 extern void _PyDebug_PrintTotalRefs(void);
@@ -197,7 +235,12 @@ _PyObject_IS_GC(PyObject *obj)
 {
     return (PyType_IS_GC(Py_TYPE(obj))
             && (Py_TYPE(obj)->tp_is_gc == NULL
-                || Py_TYPE(obj)->tp_is_gc(obj)));
+                || Py_TYPE(obj)->tp_is_gc(obj))
+            /* GraalPy change: our built-in types do not yet consistently
+               declare the HAVE_GC flag. So, also check if 'tp_traverse'
+               is there. */
+            && (!points_to_py_handle_space(obj)
+                || Py_TYPE(obj)->tp_traverse != NULL));
 }
 
 // Fast inlined version of PyType_IS_GC()
@@ -206,12 +249,15 @@ _PyObject_IS_GC(PyObject *obj)
 static inline size_t
 _PyType_PreHeaderSize(PyTypeObject *tp)
 {
-    // GraalPy change: remove CPython's GC header; also we put only one pointer for dict, we don't store it inlined
-    return _PyType_HasFeature(tp, Py_TPFLAGS_MANAGED_DICT) * sizeof(PyObject *);
+    // GraalPy change: we put only one pointer for dict, we don't store it inlined
+    return _PyType_IS_GC(tp) * sizeof(PyGC_Head) +
+        _PyType_HasFeature(tp, Py_TPFLAGS_MANAGED_DICT) *  sizeof(PyObject *);
 }
 
 void _PyObject_GC_Link(PyObject *op);
 
+void _GraalPyObject_GC_NotifyOwnershipTransfer(PyObject *op);
+
 // Usage: assert(_Py_CheckSlotResult(obj, "__getitem__", result != NULL));
 extern int _Py_CheckSlotResult(
     PyObject *obj,
@@ -245,8 +291,7 @@ static inline PyDictValues **_PyObject_ValuesPointer(PyObject *obj)
 static inline PyObject **_PyObject_ManagedDictPointer(PyObject *obj)
 {
     assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT);
-    // GraalPy change: ours is at a different offset
-    return ((PyObject **)obj)-1;
+    return ((PyObject **)obj)-3;
 }
 
 #define MANAGED_DICT_OFFSET (((int)sizeof(PyObject *))*-3)

graalpython/com.oracle.graal.python.cext/include/pydtrace.h

@@ -0,0 +1,65 @@
+/* Copyright (c) 2018, 2024, Oracle and/or its affiliates.
+ * Copyright (C) 1996-2023 Python Software Foundation
+ *
+ * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+ */
+
+/* Static DTrace probes interface */
+
+#ifndef Py_DTRACE_H
+#define Py_DTRACE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef WITH_DTRACE
+
+#include "pydtrace_probes.h"
+
+/* pydtrace_probes.h, on systems with DTrace, is auto-generated to include
+   `PyDTrace_{PROBE}` and `PyDTrace_{PROBE}_ENABLED()` macros for every probe
+   defined in pydtrace_provider.d.
+
+   Calling these functions must be guarded by a `PyDTrace_{PROBE}_ENABLED()`
+   check to minimize performance impact when probing is off. For example:
+
+       if (PyDTrace_FUNCTION_ENTRY_ENABLED())
+           PyDTrace_FUNCTION_ENTRY(f);
+*/
+
+#else
+
+/* Without DTrace, compile to nothing. */
+
+static inline void PyDTrace_LINE(const char *arg0, const char *arg1, int arg2) {}
+static inline void PyDTrace_FUNCTION_ENTRY(const char *arg0, const char *arg1, int arg2)  {}
+static inline void PyDTrace_FUNCTION_RETURN(const char *arg0, const char *arg1, int arg2) {}
+static inline void PyDTrace_GC_START(int arg0) {}
+static inline void PyDTrace_GC_DONE(Py_ssize_t arg0) {}
+static inline void PyDTrace_INSTANCE_NEW_START(int arg0) {}
+static inline void PyDTrace_INSTANCE_NEW_DONE(int arg0) {}
+static inline void PyDTrace_INSTANCE_DELETE_START(int arg0) {}
+static inline void PyDTrace_INSTANCE_DELETE_DONE(int arg0) {}
+static inline void PyDTrace_IMPORT_FIND_LOAD_START(const char *arg0) {}
+static inline void PyDTrace_IMPORT_FIND_LOAD_DONE(const char *arg0, int arg1) {}
+static inline void PyDTrace_AUDIT(const char *arg0, void *arg1) {}
+
+static inline int PyDTrace_LINE_ENABLED(void) { return 0; }
+static inline int PyDTrace_FUNCTION_ENTRY_ENABLED(void) { return 0; }
+static inline int PyDTrace_FUNCTION_RETURN_ENABLED(void) { return 0; }
+static inline int PyDTrace_GC_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_GC_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_NEW_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_NEW_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_DELETE_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_DELETE_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_IMPORT_FIND_LOAD_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_IMPORT_FIND_LOAD_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_AUDIT_ENABLED(void) { return 0; }
+
+#endif /* !WITH_DTRACE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_DTRACE_H */