tmp

Author: xFrednet

Objects/tracingregionobject.c

@@ -27,6 +27,8 @@
 /* Macro that jumps to error, if the expression `x` does not succeed. */
 #define SUCCEEDS(x) do { int r = (x); if (r != 0) goto error; } while (0)
 
+#define Region_Check(x) Py_IS_TYPE((x), &_PyTracingRegion_Type)
+
 // ###################################################################
 // Copied from gc.c
 // ###################################################################
@@ -296,10 +298,93 @@ get_reachable_proc(PyTypeObject *tp)
 static void
 gc_list_dissolve(PyGC_Head *list) {
     struct _gc_runtime_state* gc_state = get_gc_state();
-    //gc_list_merge(list, &(gc_state->young.head));
     gc_list_merge(list, &(gc_state->old[0].head));
 }
 
+static void detach_weak_refs(PyGC_Head *gc_list) {
+    PyGC_Head *current = GC_NEXT(gc_list);
+    while (current != gc_list) {
+        PyObject *item = _Py_FROM_GC(current);
+#ifdef PY_DEBUG
+        Py_ssize_t weak_ctn = _PyWeakref_GetWeakrefCount(item);
+        if (weak_ctn) {
+            trace("- Clearing %zd weak references to %p", weak_ctn, item);
+        }
+#endif
+        if (_PyType_SUPPORTS_WEAKREFS(Py_TYPE(item))) {
+            _PyWeakref_ClearWeakRefsNoCallbacks(item);
+        }
+
+        current = GC_NEXT(current);
+    }
+}
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *dict;
+    // The GC list containing all objects while the region is closed. The bridge
+    // object is not in this GC list but in the list of the owning region or in no
+    // list if it's owned by a released cown.
+    PyGC_Head gc_list;
+    // FIXME(regions): This can be inferred from the status of the gc_list
+    // or stored in the lower bits of the GC list. For now we keep it separate
+    // for the prototype
+    bool open;
+    // This is the number of references from inside the region that reference
+    // this bridge object.
+    Py_ssize_t internal_bridge_refs;
+} TracingRegionObject;
+
+const int PER_REGION_TRACE_LIMIT = 2;
+
+typedef struct {
+    // This is the stack of pending regions needing to be closed to close
+    // this region tree. Objects will be inqueued `PER_REGION_TRACE_LIMIT`
+    // times. It the region is not closed when it hits the limit, the closing
+    // will fail.
+    PyObject *pending;
+    // This tracks per region in the tree how often it has been traversed.
+    // Some things require the trace to be redone, namely freezing an object
+    // as that may create references and finding an open sub-region, as that
+    // one needs to be traced and closed first.
+    //
+    // We limit the number of times we restart the trace per region.
+    // Theoretically, this may reject some programs that would eventually
+    // reach a fixed point, but if somebody wants to do dark magic, that's
+    // really not our problem.
+    _Py_hashtable_t *traceing_counts;
+} tree_trace_state_t;
+
+static void tree_trace_state_destroy(tree_trace_state_t* state) {
+    if (state->traceing_counts) {
+        _Py_hashtable_destroy(state->traceing_counts);
+        state->traceing_counts = NULL;
+    }
+    if (state->pending) {
+        Py_CLEAR(state->pending);
+    }
+}
+
+static int tree_trace_state_init(tree_trace_state_t* state) {
+    state->traceing_counts = _Py_hashtable_new(
+        _Py_hashtable_hash_ptr,
+        _Py_hashtable_compare_direct);
+    if (state->traceing_counts == NULL) {
+        goto error;
+    }
+
+    state->pending = PyList_New(0);
+    if (state->pending == NULL) {
+        goto error;
+    }
+
+    return 0;
+error:
+    trace_state_destroy(state);
+    return -1;
+}
+
+// TODO: Continue Migration
 
 typedef struct {
     // These are the objects with incoming references, that
@@ -751,41 +836,26 @@ static int trace_object(PyObject* obj, trace_info_t* result, PyGC_Head *gc_list)
     return res;
 }
 
-static void detach_weak_refs(PyGC_Head *gc_list) {
-    PyGC_Head *current = GC_NEXT(gc_list);
-    while (current != gc_list) {
-        PyObject *item = _Py_FROM_GC(current);
-#ifdef PY_DEBUG
-        Py_ssize_t weak_ctn = _PyWeakref_GetWeakrefCount(item);
-        if (weak_ctn) {
-            trace("- Clearing %zd weak references to %p", weak_ctn, item);
-        }
-#endif
-        if (_PyType_SUPPORTS_WEAKREFS(Py_TYPE(item))) {
-            _PyWeakref_ClearWeakRefsNoCallbacks(item);
-        }
+static int try_close_region_tree(PyObject *root) {
+    tree_trace_state_t state;
+    if (tree_trace_state_init(&state)) {
+        return -1;
+    }
 
-        current = GC_NEXT(current);
+    while (PyList_GET_SIZE(state.pending) > 0) {
+        // Find the next pending item:
+        PyObject *region = list_pop(state.pending);
+        assert(Region_Check(region));
+
+
+        // TODO: Continue....
     }
 }
 
 // ###################################################################
 // Region Object
 // ###################################################################
 
-typedef struct {
-    PyObject_HEAD
-    PyObject *dict;
-    // The GC list containing all objects while the region is closed. The bridge
-    // object is not in this GC list but in the list of the owning region or in no
-    // list if it's owned by a released cown.
-    PyGC_Head gc_list;
-    // FIXME(regions): This can be inferred from the status of the gc_list
-    // or stored in the lower bits of the GC list. For now we keep it separate
-    // for the prototype
-    bool open;
-} TracingRegionObject;
-
 static int
 TracingRegion_init(TracingRegionObject *self, PyObject *args, PyObject *kwargs) {
     gc_list_init(&self->gc_list);
@@ -894,24 +964,6 @@ TracingRegion_set_dict(PyObject *op, PyObject *value, void *Py_UNUSED(context))
     return 0;
 }
 
-static PyObject* TracingRegion_trace(PyObject *op) {
-    trace_info_t result;
-    if (trace_object(op, &result, NULL)) {
-        return NULL;  // propagate Python exception
-    }
-
-    if (result.obj_table != NULL) {
-        _Py_hashtable_destroy(result.obj_table);
-    }
-
-    PyObject *t = Py_BuildValue("(ii)", result.objs, result.incoming_refs);
-    if (t == NULL) {
-        return NULL;  // propagate Python exception
-    }
-
-    return t;
-}
-
 // State threaded through `_report_incoming_ref` while building the
 // "region could not be closed" error message.
 typedef struct {
@@ -1051,8 +1103,6 @@ int _PyTracingRegion_IsClosed(PyObject* region) {
 }
 
 static PyMethodDef TracingRegion_methods[] = {
-    {"trace", _PyCFunction_CAST(TracingRegion_trace), METH_NOARGS,
-        "This traces the region and returns the number of incoming references"},
     {NULL,              NULL}           /* sentinel */
 };