Stackless issue python#94: call __init__(self, ...) stackless

This commit makes calls to an initialiser method (__init__(self)) stackless,
if soft switching is enabled.

https://bitbucket.org/stackless-dev/stackless/issues/94
(grafted from dc2e43c1dbd20f279704c287eb0e2b69e0d14c7f and 43fa00988749)

Author: Anselm Kruis

Objects/typeobject.c

@@ -715,9 +715,13 @@ type_repr(PyTypeObject *type)
     return rtn;
 }
 
+static int
+slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds);
+
 static PyObject *
 type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
+    STACKLESS_GETARG();
     PyObject *obj;
 
     if (type->tp_new == NULL) {
@@ -741,10 +745,29 @@ type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
         if (!PyType_IsSubtype(Py_TYPE(obj), type))
             return obj;
         type = Py_TYPE(obj);
-        if (type->tp_init != NULL &&
-            type->tp_init(obj, args, kwds) < 0) {
-            Py_DECREF(obj);
-            obj = NULL;
+        if (type->tp_init != NULL) {
+            initproc tp_init = type->tp_init;
+            int ret;
+#ifdef STACKLESS
+            int is_stackless;
+            if (tp_init == slot_tp_init)
+                STACKLESS_PROMOTE_ALL();
+            is_stackless = slp_try_stackless;
+#endif
+            ret = tp_init(obj, args, kwds);
+#ifdef STACKLESS
+            STACKLESS_ASSERT();
+            if (is_stackless && ret == STACKLESS_UNWINDING_MAGIC) {
+                /* It is a stackless call and it is unwinding.
+                 * the real result is in Py_UnwindToken */
+                Py_DECREF(obj);
+                return (PyObject *)Py_UnwindToken;
+            }
+#endif
+            if (ret < 0) {
+                Py_DECREF(obj);
+                obj = NULL;
+            }
         }
     }
     return obj;
@@ -3008,6 +3031,7 @@ PyTypeObject PyType_Type = {
     (inquiry)type_is_gc,                        /* tp_is_gc */
 };
 
+STACKLESS_DECLARE_METHOD(&PyType_Type, tp_call)
 
 /* The base type of all types (eventually)... except itself. */
 
@@ -5696,18 +5720,67 @@ slot_tp_descr_set(PyObject *self, PyObject *target, PyObject *value)
     return 0;
 }
 
+#ifdef STACKLESS
+PyObject *
+slp_tp_init_callback(PyFrameObject *f, int exc, PyObject *retval)
+{
+    PyThreadState *ts = PyThreadState_GET();
+    PyCFrameObject *cf = (PyCFrameObject *) f;
+
+    f = cf->f_back;
+    if (retval != NULL) {
+        if (retval != Py_None) {
+            PyErr_Format(PyExc_TypeError,
+                     "__init__() should return None, not '%.200s'",
+                     Py_TYPE(retval)->tp_name);
+            Py_DECREF(retval);
+            retval = NULL;
+        } else {
+            Py_DECREF(retval);
+            retval = cf->ob1;
+            cf->ob1 = NULL;
+        }
+    }
+    ts->frame = f;
+    Py_DECREF(cf);
+    return STACKLESS_PACK(retval);
+}
+#endif
+
 static int
 slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
-    STACKLESS_GETARG(); /* not yet supported */
+    STACKLESS_GETARG();
     _Py_IDENTIFIER(__init__);
     PyObject *meth = lookup_method(self, &PyId___init__);
     PyObject *res;
 
     if (meth == NULL)
         return -1;
+#ifdef STACKLESS
+    if (stackless) {
+        PyCFrameObject *f = slp_cframe_new(slp_tp_init_callback, 1);
+        if (f == NULL)
+            return -1;
+        Py_INCREF(self);
+        f->ob1 = self;
+        PyThreadState_GET()->frame = (PyFrameObject *) f;
+    }
+#endif
+    STACKLESS_PROMOTE_ALL();
     res = PyObject_Call(meth, args, kwds);
+    STACKLESS_ASSERT();
     Py_DECREF(meth);
+#ifdef STACKLESS
+    if (stackless && !STACKLESS_UNWINDING(res)) {
+        /* required, because added a C-frame */
+        STACKLESS_PACK(res);
+        return STACKLESS_UNWINDING_MAGIC;
+    }
+    if (STACKLESS_UNWINDING(res)) {
+        return STACKLESS_UNWINDING_MAGIC;
+    }
+#endif
     if (res == NULL)
         return -1;
     if (res != Py_None) {

Stackless/changelog.txt

@@ -9,6 +9,13 @@ What's New in Stackless 3.X.X?
 
 *Release date: 20XX-XX-XX*
 
+- https://bitbucket.org/stackless-dev/stackless/issues/94
+  Calls to __init__(self, ...) are now stackless, if
+  soft-switching is enabled.
+  Note: pickling and unpickling an object while its __init__() method runs,
+  may cause unexpected interactions between the object reconstruction and the
+  remaining part of __init__().
+
 - https://bitbucket.org/stackless-dev/stackless/issues/98
   Prevent an unlikely NULL-pointer access in safe_pickle.c pickle_callback().
   The bug is very old and might affect multiprocessing.

Stackless/core/stackless_impl.h

@@ -114,6 +114,8 @@ PyAPI_FUNC(PyObject *) PyEval_EvalFrame_with_cleanup(struct _frame *f,  int thro
 /* other eval_frame functions from module/scheduling.c */
 PyAPI_FUNC(PyObject *) slp_restore_exception(PyFrameObject *f, int exc, PyObject *retval);
 PyAPI_FUNC(PyObject *) slp_restore_tracing(PyFrameObject *f, int exc, PyObject *retval);
+/* other eval_frame functions from Objects/typeobject.c */
+PyObject * slp_tp_init_callback(PyFrameObject *f, int exc, PyObject *retval);
 
 /* rebirth of software stack avoidance */
 
@@ -173,6 +175,9 @@ PyAPI_FUNC(PyTaskletObject *) slp_get_watchdog(PyThreadState *ts, int interrupt)
 #define STACKLESS_UNWINDING(obj) \
     ((PyObject *) (obj) == (PyObject *) Py_UnwindToken)
 
+/* an arbitrary positive number */
+#define STACKLESS_UNWINDING_MAGIC 0x7fedcba9
+
 /* macros for setting/resetting the stackless flag */
 
 #define STACKLESS_GETARG() int stackless = (stackless = slp_try_stackless, \

Stackless/core/stackless_methods.h

@@ -1,5 +1,5 @@
 /*
- * this file was generated from the Python C sources using the script
+ * this file was generated from the Python(r) C sources using the script
  * Stackless/core/extract_slp_methods.py .
  * please don't edit this output, but work on the script.
  */
@@ -15,18 +15,20 @@ typedef struct {
 
 static _stackless_method _stackless_methtable[] = {
     /* from classobject.c */
-    {&PyMethod_Type,        MFLAG_OFS(tp_call)},
+    {&PyMethod_Type,            MFLAG_OFS(tp_call)},
     /* from descrobject.c */
     {&PyMethodDescr_Type,        MFLAG_OFS(tp_call)},
     {&PyClassMethodDescr_Type,    MFLAG_OFS(tp_call)},
-    {&_PyMethodWrapper_Type,        MFLAG_OFS(tp_call)},
+    {&_PyMethodWrapper_Type,    MFLAG_OFS(tp_call)},
     /* from funcobject.c */
-    {&PyFunction_Type,        MFLAG_OFS(tp_call)},
+    {&PyFunction_Type,            MFLAG_OFS(tp_call)},
     /* from genobject.c */
-    {&PyGen_Type,            MFLAG_OFS(tp_iternext)},
+    {&PyGen_Type,                MFLAG_OFS(tp_iternext)},
     /* from methodobject.c */
-    {&PyCFunction_Type,        MFLAG_OFS(tp_call)},
+    {&PyCFunction_Type,            MFLAG_OFS(tp_call)},
+    /* from typeobject.c */
+    {&PyType_Type,                MFLAG_OFS(tp_call)},
     /* from channelobject.c */
-    {&PyChannel_Type,                   MFLAG_OFS(tp_iternext)},
+    {&PyChannel_Type,            MFLAG_OFS(tp_iternext)},
     {0, 0} /* sentinel */
 };

Stackless/pickling/prickelpit.c

@@ -744,6 +744,7 @@ DEF_INVALID_EXEC(eval_frame_with_cleanup)
 DEF_INVALID_EXEC(channel_seq_callback)
 DEF_INVALID_EXEC(slp_restore_exception)
 DEF_INVALID_EXEC(slp_restore_tracing)
+DEF_INVALID_EXEC(slp_tp_init_callback)
 
 static PyTypeObject wrap_PyFrame_Type;
 
@@ -1126,6 +1127,8 @@ static int init_frametype(void)
                              slp_restore_exception, REF_INVALID_EXEC(slp_restore_exception))
         || slp_register_execute(&PyCFrame_Type, "slp_restore_tracing",
                              slp_restore_tracing, REF_INVALID_EXEC(slp_restore_tracing))
+        || slp_register_execute(&PyCFrame_Type, "slp_tp_init_callback",
+                             slp_tp_init_callback, REF_INVALID_EXEC(slp_tp_init_callback))
         || init_type(&wrap_PyFrame_Type, initchain);
 }
 #undef initchain

Stackless/unittests/test_pickle.py

@@ -224,6 +224,20 @@ def ctxpickling(testCase, n, when, expect_type, suppress_exc):
     return "OK"
 
 
+class InitTestClass:
+    def __init__(self, testcase):
+        testcase.started = True
+        schedule()
+
+
+def inittest(testcase, cls):
+    # test pickling of stackless __init__
+    testcase.started = False
+    obj = cls(testcase)
+    testcase.assertTrue(testcase.started)
+    return "OK"
+
+
 def is_soft():
     softswitch = stackless.enable_softswitch(0)
     stackless.enable_softswitch(softswitch)
@@ -453,6 +467,9 @@ def testCtx_exit_3(self):
     def testCtx_exit_4(self):
         self.run_pickled(ctxpickling, self, 1, 'exit', RuntimeError, True)
 
+    def test__init__(self):
+        self.run_pickled(inittest, self, InitTestClass)
+
     def testFakeModules(self):
         types.ModuleType('fakemodule!')