Fix a problem with delayed decref of tasklets. We need to know if slp_schedule_task() actually did schedule a new task, or if it was a no-op (due to same-task switching or some error). Fix the api to get information about that and manually clear the delayed decref flag when appropriate.

This fixes an assertion in test/taskspeed.py for debug builds.

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

Author: kristjan.jonsson

Stackless/core/stackless_impl.h

@@ -376,7 +376,8 @@ PyAPI_FUNC(PyObject *) slp_tasklet_new(PyTypeObject *type, PyObject *args,
 
 PyAPI_FUNC(PyObject *) slp_schedule_task(PyTaskletObject *prev,
                                          PyTaskletObject *next,
-                                         int stackless);
+                                         int stackless,
+                                         int *did_switch);
 
 PyAPI_FUNC(int) initialize_main_and_current(void);
 

Stackless/module/channelobject.c

@@ -481,7 +481,7 @@ generic_channel_action(PyChannelObject *self, PyObject *arg, int dir, int stackl
         }
     }
     ts->st.runflags |= runflags; /* extra info for slp_schedule_task */
-    retval = slp_schedule_task(source, target, stackless);
+    retval = slp_schedule_task(source, target, stackless, 0);
 
     if (interthread) {
         if (cando) {

Stackless/module/scheduling.c

@@ -591,7 +591,7 @@ new_lock(void)
 #endif
 
 static PyObject *
-schedule_task_block(PyTaskletObject *prev, int stackless)
+schedule_task_block(PyTaskletObject *prev, int stackless, int *did_switch)
 {
     PyThreadState *ts = PyThreadState_GET();
     PyObject *retval;
@@ -615,12 +615,12 @@ schedule_task_block(PyTaskletObject *prev, int stackless)
              */
             if (PyBomb_Check(prev->tempval))
                 TASKLET_SETVAL(ts->st.main, prev->tempval);
-            return slp_schedule_task(prev, ts->st.main, stackless);
+            return slp_schedule_task(prev, ts->st.main, stackless, did_switch);
         }
         if (!(retval = make_deadlock_bomb()))
             return NULL;
         TASKLET_SETVAL_OWN(prev, retval);
-        return slp_schedule_task(prev, prev, stackless);
+        return slp_schedule_task(prev, prev, stackless, did_switch);
     }
 #ifdef WITH_THREAD
     if (ts->st.thread.self_lock == NULL) {
@@ -679,7 +679,7 @@ schedule_task_block(PyTaskletObject *prev, int stackless)
     next = prev;
 #endif
     /* this must be after releasing the locks because of hard switching */
-    retval = slp_schedule_task(prev, next, stackless);
+    retval = slp_schedule_task(prev, next, stackless, did_switch);
     PR("schedule() is done");
     return retval;
 }
@@ -688,7 +688,8 @@ schedule_task_block(PyTaskletObject *prev, int stackless)
 
 static PyObject *schedule_task_unblock(PyTaskletObject *prev,
                                        PyTaskletObject *next,
-                                       int stackless)
+                                       int stackless,
+                                       int *did_switch)
 {
     PyThreadState *ts = PyThreadState_GET();
     PyThreadState *nts = next->cstate->tstate;
@@ -724,7 +725,7 @@ static PyObject *schedule_task_unblock(PyTaskletObject *prev,
     Py_END_ALLOW_THREADS
 
     /* get myself ready */
-    retval = slp_schedule_task(prev, prev, stackless);
+    retval = slp_schedule_task(prev, prev, stackless, did_switch);
 
     /* see whether the other thread still exists and is really blocked */
     if (is_thread_alive(thread_id) && nts->st.thread.is_locked) {
@@ -804,21 +805,25 @@ static void slp_schedule_soft_irq(PyThreadState *ts, PyTaskletObject *prev,
 
 
 PyObject *
-slp_schedule_task(PyTaskletObject *prev, PyTaskletObject *next, int stackless)
+slp_schedule_task(PyTaskletObject *prev, PyTaskletObject *next, int stackless,
+                  int *did_switch)
 {
     PyThreadState *ts = PyThreadState_GET();
     PyCStackObject **cstprev;
     PyObject *retval;
     int (*transfer)(PyCStackObject **, PyCStackObject *, PyTaskletObject *);
     int no_soft_irq;
+    
+    if (did_switch)
+        *did_switch = 0; /* only set this if an actual switch occurs */
 
     if (next == NULL) {
-        return schedule_task_block(prev, stackless);
+        return schedule_task_block(prev, stackless, did_switch);
     }
 #ifdef WITH_THREAD
     /* note that next->cstate is undefined if it is ourself */
     if (next->cstate != NULL && next->cstate->tstate != ts) {
-        return schedule_task_unblock(prev, next, stackless);
+        return schedule_task_unblock(prev, next, stackless, did_switch);
     }
 #endif
 
@@ -915,6 +920,8 @@ slp_schedule_task(PyTaskletObject *prev, PyTaskletObject *next, int stackless)
     ts->recursion_depth = next->recursion_depth;
 
     ts->st.current = next;
+    if (did_switch)
+        *did_switch = 1;
 
     assert(next->cstate != NULL);
     if (next->cstate->nesting_level != 0) {
@@ -973,6 +980,8 @@ slp_schedule_task(PyTaskletObject *prev, PyTaskletObject *next, int stackless)
         TASKLET_CLAIMVAL(prev, &retval);
         if (PyBomb_Check(retval))
             retval = slp_bomb_explode(retval);
+        if (did_switch)
+            *did_switch = 1;
         return retval;
     }
     else {
@@ -1066,9 +1075,13 @@ schedule_task_destruct(PyTaskletObject *prev, PyTaskletObject *next)
     ts->st.del_post_switch = (PyObject *)prev;
 
     /* do a soft switch */
-    if (prev != next)
-        retval = slp_schedule_task(prev, next, 1);
-    else {
+    if (prev != next) {
+        int switched;
+        retval = slp_schedule_task(prev, next, 1, &switched);
+        if (!switched)
+            /* something happened, cancel prev's decref */
+            ts->st.del_post_switch  = 0;
+    } else {
         /* main is exiting */
         TASKLET_CLAIMVAL(prev, &retval);
         if (PyBomb_Check(retval))

Stackless/module/stacklessmodule.c

@@ -45,6 +45,7 @@ PyStackless_Schedule(PyObject *retval, int remove)
     PyThreadState *ts = PyThreadState_GET();
     PyTaskletObject *prev = ts->st.current, *next = prev->next;
     PyObject *ret = NULL;
+    int switched;
 
     if (ts->st.main == NULL) return PyStackless_Schedule_M(retval, remove);
     /* make sure we hold a reference to the previous tasklet */
@@ -65,7 +66,14 @@ PyStackless_Schedule(PyObject *retval, int remove)
     assert(ts->st.del_post_switch == NULL);
     ts->st.del_post_switch = (PyObject*)prev;
 
-    return slp_schedule_task(prev, next, stackless);
+    ret = slp_schedule_task(prev, next, stackless, &switched);
+
+    /* however, if this was a no-op (e.g. prev==next, or an error occurred)
+     * we need to decref prev ourselves
+     */
+    if (!switched)
+        Py_CLEAR(ts->st.del_post_switch);
+    return ret;
 }
 
 PyObject *
@@ -226,7 +234,7 @@ interrupt_timeout_return(void)
     else
         current->flags.pending_irq = 0;
 
-    return slp_schedule_task(ts->st.current, ts->st.main, 1);
+    return slp_schedule_task(ts->st.current, ts->st.main, 1, 0);
 }
 
 static PyObject *
@@ -270,7 +278,7 @@ PyStackless_RunWatchdogEx(long timeout, int flags)
 
     /* now let them run until the end. */
     ts->st.runflags = flags;
-    retval = slp_schedule_task(ts->st.main, ts->st.current, 0);
+    retval = slp_schedule_task(ts->st.main, ts->st.current, 0, 0);
     ts->st.runflags = 0;
     ts->st.interrupt = NULL;
 

Stackless/module/taskletobject.c

@@ -524,7 +524,7 @@ static TASKLET_RUN_HEAD(impl_tasklet_run)
     if (ts->st.main == NULL) return PyTasklet_Run_M(task);
     if (PyTasklet_Insert(task))
         return NULL;
-    return slp_schedule_task(ts->st.current, task, stackless);
+    return slp_schedule_task(ts->st.current, task, stackless, 0);
 }
 
 static TASKLET_RUN_HEAD(wrap_tasklet_run)
@@ -739,7 +739,7 @@ post_schedule_remove(PyFrameObject *f, int exc, PyObject *retval)
     slp_current_remove(); /* reference used in tempval */
     TASKLET_SETVAL_OWN(self, parent);
     TASKLET_SETVAL_OWN(parent, retval); /* consume it */
-    ret = slp_schedule_task(parent, self, 1);
+    ret = slp_schedule_task(parent, self, 1, 0);
     return ret;
 }
 
@@ -891,7 +891,7 @@ static TASKLET_RAISE_EXCEPTION_HEAD(impl_tasklet_raise_exception)
         TASKLET_CLAIMVAL(self, &bomb);
         return slp_bomb_explode(bomb);
     }
-    return slp_schedule_task(ts->st.current, self, stackless);
+    return slp_schedule_task(ts->st.current, self, stackless, 0);
 }