Merge branch 'slp-issue-192' into slp-issue-199

Author: Anselm Kruis

Doc/library/stackless/tasklets.rst

@@ -342,6 +342,19 @@ The ``tasklet`` class
      # Implement unsafe logic here.
      t.set_ignore_nesting(old_value)
 
+.. method:: tasklet.__del__()
+
+   .. versionadded:: 3.7
+
+   Finalize the tasklet. This is a :pep:`442` finalizer. If this tasklet is
+   alive and has a non-trivial C-state attached, the finalizer repeatedly
+   kills the tasklet for upmost 10 times until it is dead. Then, if this
+   tasklet still has non-trivial C-state attached, the finalizer appends the
+   tasklet to :data:`gc.garbage`. This is done, because releasing the C-state
+   could cause undefined behavior.
+
+   You should not call this method from |PY|-code.
+
 The following (read-only) attributes allow tasklet state to be checked:
 
 .. attribute:: tasklet.alive

Include/objimpl.h

@@ -336,8 +336,6 @@ 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

@@ -419,48 +419,9 @@ untrack_dicts(PyGC_Head *head)
 }
 
 /* Return true if object has a pre-PEP 442 finalization method. */
-/* 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;
-}
-
 static int
 has_legacy_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;
-
     return op->ob_type->tp_del != NULL;
 }
 

Stackless/changelog.txt

@@ -9,6 +9,16 @@ What's New in Stackless 3.X.X?
 
 *Release date: 20XX-XX-XX*
 
+- https://github.com/stackless-dev/stackless/issues/192
+  Use the PEP 442 mechanic to finalize a tasklet instead of a arcane logic in
+  tp_dealloc. The finalizer can be called from Python-code: tasklet.__del__().
+  Stackless calls the finalizer only once. The finalizer repeatedly kills the
+  tasklet until it is dead but at most 10-times.
+  If the finalizer can't kill the C-state it adds the tasklet to gc.garbage.
+  This change unifies the behavior of de-allocation caused by ref-counting and
+  de-allocation caused by GC. And it brings the behavior more in line with
+  generators.
+
 - https://github.com/stackless-dev/stackless/issues/199
   Enable stackless calls of coroutines wrapped in "asyncio._CTask", if
   soft-switching is enabled. Now asyncio runs coroutines stackless.

Stackless/core/stackless_impl.h

@@ -727,8 +727,6 @@ int slp_return_wrapper_hard(PyObject *retval);
 int slp_int_wrapper(PyObject *retval);
 int slp_current_wrapper(int(*func)(PyTaskletObject*),
                         PyTaskletObject *task);
-int slp_resurrect_and_kill(PyObject *self,
-                           void(*killer)(PyObject *));
 
 /* stackless pickling support */
 PyObject * slp_coro_wrapper_reduce(PyObject *o, PyTypeObject * wrapper_type);

Stackless/core/stackless_util.c

@@ -124,67 +124,6 @@ slp_current_wrapper( int(*func)(PyTaskletObject*), PyTaskletObject *task )
     return ret;
 }
 
-int
-slp_resurrect_and_kill(PyObject *self, void(*killer)(PyObject *))
-{
-    /* modelled after typeobject.c's slot_tp_del */
-
-    PyObject *error_type, *error_value, *error_traceback;
-
-    /* this is different from typeobject.c's slot_tp_del: our callers already 
-       called PyObject_GC_UnTrack(self) */
-    assert(PyObject_IS_GC(self) && ! _PyObject_GC_IS_TRACKED(self));
-
-    /* Temporarily resurrect the object. */
-    assert(Py_REFCNT(self) == 0);
-    Py_REFCNT(self) = 1;
-
-    /* Save the current exception, if any. */
-    PyErr_Fetch(&error_type, &error_value, &error_traceback);
-
-    killer(self);
-
-    /* Restore the saved exception. */
-    PyErr_Restore(error_type, error_value, error_traceback);
-
-    /* Undo the temporary resurrection; can't use DECREF here, it would
-     * cause a recursive call.
-     */
-    assert(Py_REFCNT(self) > 0);
-    if (--Py_REFCNT(self) == 0)
-        return 0;    /* this is the normal path out */
-
-    /* __del__ resurrected it!  Make it look like the original Py_DECREF
-     * never happened.
-     */
-    {
-        Py_ssize_t refcnt = Py_REFCNT(self);
-        _Py_NewReference(self);
-        Py_REFCNT(self) = refcnt;
-    }
-    /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
-     * we need to undo that. */
-    _Py_DEC_REFTOTAL;
-    /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
-     * chain, so no more to do there.
-     * If COUNT_ALLOCS, the original decref bumped tp_frees, and
-     * _Py_NewReference bumped tp_allocs:  both of those need to be
-     * undone.
-     */
-#ifdef COUNT_ALLOCS
-    --Py_TYPE(self)->tp_frees;
-    --Py_TYPE(self)->tp_allocs;
-#endif
-    /* This code copied from iobase_dealloc() (in 3.0) */
-    /* When called from a heap type's dealloc, the type will be
-       decref'ed on return (see e.g. subtype_dealloc in typeobject.c).
-       This will undo that, thus preventing a crash.  But such a type
-       _will_ have had its dict and slots cleared. */
-    if (PyType_HasFeature(Py_TYPE(self), Py_TPFLAGS_HEAPTYPE))
-        Py_INCREF(Py_TYPE(self));
-
-    return -1;
-}
 
 /*
  * A thread id is either an unsigned long or the special value -1.

Stackless/module/channelobject.c

@@ -11,9 +11,6 @@
 #include "core/stackless_impl.h"
 #include "channelobject.h"
 
-static void
-channel_remove_all(PyObject *ob);
-
 Py_LOCAL_INLINE(PyChannelFlagStruc)
 channel_flags_from_integer(int flags) {
 #if defined(SLP_USE_NATIVE_BITFIELD_LAYOUT) && SLP_USE_NATIVE_BITFIELD_LAYOUT
@@ -62,23 +59,19 @@ channel_traverse(PyChannelObject *ch, visitproc visit, void *arg)
 
 static void
 channel_clear(PyObject *ob)
-{
-    /* this function does nothing but decref, so it's safe to use */
-    channel_remove_all(ob);
-}
-
-static void
-channel_remove_all(PyObject *ob)
 {
     PyChannelObject *ch = (PyChannelObject *) ob;
+    assert(PyChannel_Check(ob));
 
     /*
      * remove all tasklets and hope they will die.
      * Note that the channel might receive new actions
      * during tasklet deallocation, so we don't even know
      * if it will have the same direction. :-/
      */
+    ch->flags.closing = 1;
     while (ch->balance) {
+        /* this function does nothing but setting task->flags.blocked = 0, so it's safe to use */
         ob = (PyObject *) slp_channel_remove(ch, NULL, NULL, NULL);
         Py_DECREF(ob);
     }
@@ -88,15 +81,10 @@ static void
 channel_dealloc(PyObject *ob)
 {
     PyChannelObject *ch = (PyChannelObject *) ob;
-    PyObject_GC_UnTrack(ob);
 
-    if (ch->balance) {
-        if (slp_resurrect_and_kill(ob, channel_remove_all)) {
-            /* the beast has grown new references */
-            PyObject_GC_Track(ob);
-            return;
-        }
-    }
+
+    PyObject_GC_UnTrack(ob);
+    channel_clear(ob);
     if (ch->chan_weakreflist != NULL)
         PyObject_ClearWeakRefs((PyObject *)ch);
     Py_TYPE(ob)->tp_free(ob);
@@ -1152,7 +1140,7 @@ channel_setstate(PyObject *self, PyObject *args)
                           &PyList_Type, &lis))
         return NULL;
 
-    channel_remove_all((PyObject *) ch);
+    channel_clear((PyObject *) ch);
     n = PyList_GET_SIZE(lis);
     ch->flags = channel_flags_from_integer(flags);
     dir = balance > 0 ? 1 : -1;