Path gcmodule so that objects themselves can decide if they can be collected.

Make tasklet objects uncollectable if they belong to a different thread than the one doing the collection.  Otherwise, they would get inserted into the target thread's queue, but their frame object would have been cleared and they were defunct.  Killing tasklets works on the same thread because then task switching can be made immediate.

This fixes a very hard to repro bug with test/taskspeed.py

git-svn-id: http://svn.python.org/projects/stackless/trunk@82436 6015fed2-1504-0410-9fe1-9d1591cc4771

Author: kristjan.jonsson

Include/objimpl.h

@@ -309,6 +309,8 @@ PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t);
 PyAPI_FUNC(void) PyObject_GC_Track(void *);
 PyAPI_FUNC(void) PyObject_GC_UnTrack(void *);
 PyAPI_FUNC(void) PyObject_GC_Del(void *);
+/* STACKLESS addition */
+PyAPI_FUNC(void) PyObject_GC_Collectable(PyObject *, visitproc, void*, int);
 
 #define PyObject_GC_New(type, typeobj) \
                 ( (type *) _PyObject_GC_New(typeobj) )

Modules/gcmodule.c

@@ -456,6 +456,34 @@ move_unreachable(PyGC_Head *young, PyGC_Head *unreachable)
     }
 }
 
+/* STACKLESS addition to support collection of tasklets */
+
+/* A traversal callback for has_finalisers.  It is a dummy, used to identify
+ * this phase of finalizer discovery by its function pointer, and thus
+ * enable the action of PyObject_GC_Collectable() below.
+ */
+static int
+visit_has_finalizer(PyObject *op, void *data)
+{
+    assert(op != NULL);
+    return 0;
+}
+
+/* An object can call this function from its traversal function
+ * to indicate whether it wishes to be collected or not
+ * this is useful for objects that have state that determines
+ * whether non-trivial actions need to be undertaken when
+ * it is deleted.
+ */
+PyAPI_FUNC(void)
+PyObject_GC_Collectable(PyObject *op, visitproc proc, void *arg,
+                        int can_collect)
+{
+    /* only do this during the move_finalizers phase */
+    if (proc == &visit_has_finalizer)
+        *(int*)arg = can_collect;
+}
+
 /* Return true if object has a finalization method.
  * CAUTION:  An instance of an old-style class has to be checked for a
  *__del__ method, and earlier versions of this used to call PyObject_HasAttr,
@@ -466,6 +494,17 @@ move_unreachable(PyGC_Head *young, PyGC_Head *unreachable)
 static int
 has_finalizer(PyObject *op)
 {
+    /* first, dynamic decision per object */
+    traverseproc traverse;
+    int collectable;
+    traverse = Py_TYPE(op)->tp_traverse;
+    collectable = -1;
+    (void) traverse(op,
+                    (visitproc)visit_has_finalizer,
+                    (void *)&collectable);
+    if (collectable >= 0)
+        return collectable == 0;
+
     if (PyInstance_Check(op)) {
         assert(delstr != NULL);
         return _PyInstance_Lookup(op, delstr) != NULL;

Stackless/core/cframeobject.c

@@ -54,15 +54,10 @@ cframe_dealloc(PyCFrameObject *cf)
 static int
 cframe_traverse(PyCFrameObject *cf, visitproc visit, void *arg)
 {
-    int err;
-
-#define VISIT(o) if (o) {if ((err = visit((PyObject *)(o), arg))) return err;}
-
-    VISIT(cf->f_back);
-    VISIT(cf->ob1);
-    VISIT(cf->ob2);
-    VISIT(cf->ob3);
-#undef VISIT
+    Py_VISIT(cf->f_back);
+    Py_VISIT(cf->ob1);
+    Py_VISIT(cf->ob2);
+    Py_VISIT(cf->ob3);
     return 0;
 }
 

Stackless/module/channelobject.c

@@ -49,14 +49,10 @@ channel_dealloc(PyObject *ob)
 static int
 channel_traverse(PyChannelObject *ch, visitproc visit, void *arg)
 {
-    int err;
     PyTaskletObject *p;
-
-#define VISIT(o) if (o) {if ((err = visit((PyObject *)(o), arg))) return err;}
     for (p = ch->head; p != (PyTaskletObject *) ch; p = p->next) {
-        VISIT(p);
+        Py_VISIT(p);
     }
-#undef VISIT
     return 0;
 }
 

Stackless/module/scheduling.c

@@ -36,15 +36,9 @@ bomb_dealloc(PyBombObject *bomb)
 static int
 bomb_traverse(PyBombObject *bomb, visitproc visit, void *arg)
 {
-    int err;
-
-#define VISIT(o) if (o) {if ((err = visit((PyObject *)(o), arg))) return err;}
-
-    VISIT(bomb->curexc_type);
-    VISIT(bomb->curexc_value);
-    VISIT(bomb->curexc_traceback);
-
-#undef VISIT
+    Py_VISIT(bomb->curexc_type);
+    Py_VISIT(bomb->curexc_value);
+    Py_VISIT(bomb->curexc_traceback);
     return 0;
 }
 

Stackless/module/taskletobject.c

@@ -47,17 +47,18 @@ slp_current_remove(void)
 static int
 tasklet_traverse(PyTaskletObject *t, visitproc visit, void *arg)
 {
-    int err;
     PyFrameObject *f;
+    PyThreadState *ts = PyThreadState_GET();
+    if (ts != t->cstate->tstate)
+        /* can't collect from this thread! */
+        PyObject_GC_Collectable((PyObject *)t, visit, arg, 0);
 
-#define VISIT(o) if (o) {if ((err = visit((PyObject *)(o), arg))) return err;}
     /* we own the "execute reference" of all the frames */
     for (f = t->f.frame; f != NULL; f = f->f_back) {
-        VISIT(f);
+        Py_VISIT(f);
     }
-    VISIT(t->tempval);
-    VISIT(t->cstate);
-#undef VISIT
+    Py_VISIT(t->tempval);
+    Py_VISIT(t->cstate);
     return 0;
 }