Stackless issue #149: Remove support for threads-less builds

Implement bpo-31370 for Stackless C-source.

Author: Anselm Kruis

Python/pystate.c

@@ -54,7 +54,6 @@ static PyInterpreterState *autoInterpreterState = NULL;
 static int autoTLSkey = -1;
 
 #ifdef STACKLESS
-#ifdef WITH_THREAD
 void
 slp_head_lock(void) {
     HEAD_LOCK();
@@ -65,7 +64,6 @@ slp_head_unlock(void) {
     HEAD_UNLOCK();
 }
 #endif
-#endif
 
 static PyInterpreterState *interp_head = NULL;
 static PyInterpreterState *interp_main = NULL;

Stackless/core/stackless_impl.h

@@ -817,15 +817,10 @@ PyObject * slp_get_channel_callback(void);
 
 /* Interpreter shutdown and thread state access */
 PyObject * slp_getthreads(PyObject *self);
-#ifdef WITH_THREAD
 void slp_head_lock(void);
 void slp_head_unlock(void);
 #define SLP_HEAD_LOCK() slp_head_lock()
 #define SLP_HEAD_UNLOCK() slp_head_unlock()
-#else
-#define SLP_HEAD_LOCK() assert(1)
-#define SLP_HEAD_UNLOCK() assert(1)
-#endif
 
 long slp_parse_thread_id(PyObject *thread_id, unsigned long *id);
 

Stackless/core/stackless_tstate.h

@@ -43,13 +43,11 @@ typedef struct _sts {
     long tick_watermark;
     long interval;
     PyObject * (*interrupt) (void);    /* the fast scheduler */
-#ifdef WITH_THREAD
     struct {
         PyObject *block_lock;                   /* to block the thread */
         int is_blocked;                         /* waiting to be unblocked */
         int is_idle;                            /* unblocked, but waiting for GIL */
     } thread;
-#endif
     PyObject *del_post_switch;                  /* To decref after a switch */
     PyObject *interrupted;                      /* The interrupted tasklet in stackles.run() */
     PyObject *watchdogs;                        /* the stack of currently running watchdogs */
@@ -121,8 +119,6 @@ void slp_kill_tasks_with_stacks(struct _ts *tstate);
     Py_CLEAR(tstate->st.unwinding_retval); \
     __STACKLESS_PYSTATE_CLEAR_NEXT_FRAME
 
-#ifdef WITH_THREAD
-
 #define STACKLESS_PYSTATE_NEW \
     __STACKLESS_PYSTATE_NEW \
     tstate->st.thread.block_lock = NULL; \
@@ -134,10 +130,3 @@ void slp_kill_tasks_with_stacks(struct _ts *tstate);
     Py_CLEAR(tstate->st.thread.block_lock); \
     tstate->st.thread.is_blocked = 0; \
     tstate->st.thread.is_idle = 0;
-
-#else
-
-#define STACKLESS_PYSTATE_NEW __STACKLESS_PYSTATE_NEW
-#define STACKLESS_PYSTATE_CLEAR __STACKLESS_PYSTATE_CLEAR
-
-#endif

Stackless/module/scheduling.c

@@ -3,9 +3,7 @@
 #ifdef STACKLESS
 #include "core/stackless_impl.h"
 
-#ifdef WITH_THREAD
 #include "pythread.h"
-#endif
 
 /******************************************************
 
@@ -673,12 +671,9 @@ slp_ensure_linkage(PyTaskletObject *t)
 static int
 is_thread_runnable(PyThreadState *ts)
 {
-#ifdef WITH_THREAD
     if (ts == PyThreadState_GET())
         return 0;
     return !ts->st.thread.is_blocked;
-#endif
-    return 0;
 }
 
 static int
@@ -707,8 +702,6 @@ make_deadlock_bomb(void)
     return slp_curexc_to_bomb();
 }
 
-#ifdef WITH_THREAD
-
 /* make sure that locks live longer than their threads */
 
 static void
@@ -774,13 +767,6 @@ void slp_thread_unblock(PyThreadState *nts)
     schedule_thread_unblock(nts);
 }
 
-#else
-
-void slp_thread_unblock(PyThreadState *nts)
-{}
-
-#endif
-
 static int
 schedule_task_block(PyObject **result, PyTaskletObject *prev, int stackless, int *did_switch)
 {
@@ -793,19 +779,16 @@ schedule_task_block(PyObject **result, PyTaskletObject *prev, int stackless, int
     /* which "main" do we awaken if we are blocking? */
     wakeup = slp_get_watchdog(ts, 0);
 
-#ifdef WITH_THREAD
     if ( !(ts->st.runflags & Py_WATCHDOG_THREADBLOCK) && wakeup->next == NULL)
         /* we also must never block if watchdog is running not in threadblocking mode */
         revive_main = 1;
 
     if (revive_main)
         assert(wakeup->next == NULL); /* target must be floating */
-#endif
 
     if (revive_main || check_for_deadlock()) {
         goto cantblock;
     }
-#ifdef WITH_THREAD
     for(;;) {
         /* store the frame back in the tasklet while we thread block, so that
          * e.g. insert doesn't think that it is dead
@@ -832,10 +815,6 @@ schedule_task_block(PyObject **result, PyTaskletObject *prev, int stackless, int
         if (check_for_deadlock())
             goto cantblock;
     }
-#else
-    next = prev;
-    Py_INCREF(next);
-#endif
     /* this must be after releasing the locks because of hard switching */
     fail = slp_schedule_task(result, prev, next, stackless, did_switch);
     Py_DECREF(next);
@@ -881,7 +860,6 @@ schedule_task_block(PyObject **result, PyTaskletObject *prev, int stackless, int
     return fail;
 }
 
-#ifdef WITH_THREAD
 static int
 schedule_task_interthread(PyObject **result,
                             PyTaskletObject *prev,
@@ -921,8 +899,6 @@ schedule_task_interthread(PyObject **result,
     return 0;
 }
 
-#endif
-
 /* deal with soft interrupts by modifying next to specify the main tasklet */
 static void slp_schedule_soft_irq(PyThreadState *ts, PyTaskletObject *prev,
                                                    PyTaskletObject **next, int not_now)
@@ -993,15 +969,13 @@ slp_schedule_task(PyObject **result, PyTaskletObject *prev, PyTaskletObject *nex
     if (next == NULL)
         return schedule_task_block(result, prev, stackless, did_switch);
 
-#ifdef WITH_THREAD
     /* note that next->cstate is undefined if it is ourself.
        Also note, that prev->cstate->tstate == NULL during Py_Finalize() */
     assert(prev->cstate == NULL || prev->cstate->tstate == NULL || prev->cstate->tstate == ts);
     /* The last condition is required during shutdown when next->cstate->tstate == NULL */
     if (next->cstate != NULL && next->cstate->tstate != ts && next != prev) {
         return schedule_task_interthread(result, prev, next, stackless, did_switch);
     }
-#endif
 
     /* switch trap. We don't trap on interthread switches because they
      * don't cause a switch on the local thread.

Stackless/module/stacklessmodule.c

@@ -309,11 +309,7 @@ PyDoc_STRVAR(getcurrentid__doc__,
 unsigned long
 PyStackless_GetCurrentId(void)
 {
-    #ifdef WITH_THREAD
     PyThreadState *ts = PyGILState_GetThisThreadState();
-#else
-    PyThreadState *ts = PyThreadState_GET();
-#endif
     PyTaskletObject *t = NULL;
     /* if there is threadstate, and there is a main tasklet, then the
      * "current" is the actively running tasklet.
@@ -336,11 +332,7 @@ PyStackless_GetCurrentId(void)
      */
     if (ts)
         return ts->thread_id;
-#ifdef WITH_THREAD
     return PyThread_get_thread_ident();
-#else
-    return 0;
-#endif
 }
 
 static PyObject *

Stackless/module/taskletobject.c

@@ -855,7 +855,6 @@ impl_tasklet_run_remove(PyTaskletObject *task, int remove)
             removed = 1;
         }
     } else {
-#ifdef WITH_THREAD
         /* interthread. */
         PyThreadState *rts = task->cstate->tstate;
         PyTaskletObject *current;
@@ -882,9 +881,6 @@ impl_tasklet_run_remove(PyTaskletObject *task, int remove)
             /* remote thread is in a weird state.  Just insert it */
             fail = impl_tasklet_insert(task);
         }
-#else
-        RUNTIME_ERROR("tasklet has an invalid thread.", NULL);
-#endif
     }
     if (fail)
         return NULL;