Speed up threading.Condition wakeup

Modules/_threadmodule.c

 
 /* Thread module */
 /* Interface to Sjoerd's portable C thread library */
 
 #include "Python.h"
 #include "structmember.h" /* offsetof */
 
 #ifndef WITH_THREAD
 #error "Error!  The rest of Python is not compiled with thread support."
 #error "Rerun configure, adding a --with-threads option."
@@ skipping 171 matching lines @@
 lock_locked_lock(lockobject *self)
 {
     return PyBool_FromLong((long)self->locked);
 }
 
 PyDoc_STRVAR(locked_doc,
 "locked() -> bool\n\
 (locked_lock() is an obsolete synonym)\n\
 \n\
 Return whether the lock is in the locked state.");
+
+PyDoc_STRVAR(lock_release_save_doc,
+"_release_save() -> state\n\
+\n\
+For internal use by `threading.Condition`.");
+
+/* restore does nothing, since _acquire_condition was used which did it
+ * automatically
+ */
+static PyObject *
+lock_acquire_restore(lockobject *self, PyObject *args)
+{
+    Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(lock_acquire_restore_doc,
+"_acquire_restore(state) -> None\n\
+\n\
+For internal use by `threading.Condition`.");
+
+/* forward decleration */
+static PyObject *
+lock_acquire_condition(lockobject *self, PyObject *args, PyObject *kwds);
+
+PyDoc_STRVAR(lock_acquire_condition_doc,
+"_acquire_condition(timeout, outer, state) -> None\n\
+\n\
+For internal use by `threading.Condition`.");
 
 static PyMethodDef lock_methods[] = {
     {"acquire_lock", (PyCFunction)lock_PyThread_acquire_lock,
      METH_VARARGS | METH_KEYWORDS, acquire_doc},
     {"acquire",      (PyCFunction)lock_PyThread_acquire_lock,
      METH_VARARGS | METH_KEYWORDS, acquire_doc},
     {"release_lock", (PyCFunction)lock_PyThread_release_lock,
      METH_NOARGS, release_doc},
     {"release",      (PyCFunction)lock_PyThread_release_lock,
      METH_NOARGS, release_doc},
     {"locked_lock",  (PyCFunction)lock_locked_lock,
      METH_NOARGS, locked_doc},
     {"locked",       (PyCFunction)lock_locked_lock,
      METH_NOARGS, locked_doc},
     {"__enter__",    (PyCFunction)lock_PyThread_acquire_lock,
      METH_VARARGS | METH_KEYWORDS, acquire_doc},
     {"__exit__",    (PyCFunction)lock_PyThread_release_lock,
      METH_VARARGS, release_doc},
+    {"_release_save",    (PyCFunction)lock_PyThread_release_lock,
+    METH_NOARGS, lock_release_save_doc},
+    {"_acquire_restore",    (PyCFunction)lock_acquire_restore,
+    METH_VARARGS, lock_acquire_restore_doc},
+    {"_acquire_condition",  (PyCFunction)lock_acquire_condition,
+    METH_VARARGS, lock_acquire_condition_doc},
     {NULL,           NULL}              /* sentinel */
 };
 
 static PyTypeObject Locktype = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "_thread.lock",                     /*tp_name*/
     sizeof(lockobject),                 /*tp_size*/
     0,                                  /*tp_itemsize*/
     /* methods */
     (destructor)lock_dealloc,           /*tp_dealloc*/
@@ skipping 145 matching lines @@
 "release()\n\
 \n\
 Release the lock, allowing another thread that is blocked waiting for\n\
 the lock to acquire the lock.  The lock must be in the locked state,\n\
 and must be locked by the same thread that unlocks it; otherwise a\n\
 `RuntimeError` is raised.\n\
 \n\
 Do note that if the lock was acquire()d several times in a row by the\n\
 current thread, release() needs to be called as many times for the lock\n\
 to be available for other threads.");
-
-static PyObject *
-rlock_acquire_restore(rlockobject *self, PyObject *arg)
-{
-    long owner;
-    unsigned long count;
-    int r = 1;
-
-    if (!PyArg_ParseTuple(arg, "kl:_acquire_restore", &count, &owner))
-        return NULL;
-
-    if (!PyThread_acquire_lock(self->rlock_lock, 0)) {
-        Py_BEGIN_ALLOW_THREADS
-        r = PyThread_acquire_lock(self->rlock_lock, 1);
-        Py_END_ALLOW_THREADS
-    }
-    if (!r) {
-        PyErr_SetString(ThreadError, "couldn't acquire lock");
-        return NULL;
-    }
-    assert(self->rlock_count == 0);
-    self->rlock_owner = owner;
-    self->rlock_count = count;
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(rlock_acquire_restore_doc,
-"_acquire_restore(state) -> None\n\
-\n\
-For internal use by `threading.Condition`.");
 
 static PyObject *
 rlock_release_save(rlockobject *self)
 {
     long owner;
     unsigned long count;
 
     if (self->rlock_count == 0) {
         PyErr_SetString(PyExc_RuntimeError,
                         "cannot release un-acquired lock");
@@ skipping 59 matching lines @@
 }
 
 
 static PyMethodDef rlock_methods[] = {
     {"acquire",      (PyCFunction)rlock_acquire,
      METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
     {"release",      (PyCFunction)rlock_release,
      METH_NOARGS, rlock_release_doc},
     {"_is_owned",     (PyCFunction)rlock_is_owned,
      METH_NOARGS, rlock_is_owned_doc},
-    {"_acquire_restore", (PyCFunction)rlock_acquire_restore,
-     METH_O, rlock_acquire_restore_doc},
+    {"_acquire_restore", (PyCFunction)lock_acquire_restore,
+     METH_O, lock_acquire_restore_doc},
     {"_release_save", (PyCFunction)rlock_release_save,
      METH_NOARGS, rlock_release_save_doc},
     {"__enter__",    (PyCFunction)rlock_acquire,
      METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
     {"__exit__",    (PyCFunction)rlock_release,
      METH_VARARGS, rlock_release_doc},
     {NULL,           NULL}              /* sentinel */
 };
 
 
@@ skipping 48 matching lines @@
         return NULL;
     self->lock_lock = PyThread_allocate_lock();
     self->locked = 0;
     self->in_weakreflist = NULL;
     if (self->lock_lock == NULL) {
         Py_DECREF(self);
         PyErr_SetString(ThreadError, "can't allocate lock");
         return NULL;
     }
     return self;
+}
+
+static PyObject *
+lock_acquire_condition(lockobject *self, PyObject *args, PyObject *kwds)
+{
+    PyObject *timeout_obj;
+    PyObject *outer_lock;
+    PyObject *outer_arg;
+    double timeout;
+    unsigned long count;
+    long owner;
+    PY_TIMEOUT_T microseconds;
+    PyLockStatus r;
+
+    /* if we can't even parse the arguments, then we cannot re-acquire the outer lock.  But that
+     * is the same if passing wrong arguments to a _aquire_restore method.
+     */
+    if (!PyArg_ParseTuple(args, "OOO:_acquire_condition", &timeout_obj, &outer_lock, &outer_arg))
+        return NULL;
+    if (Py_TYPE(outer_lock) == &RLocktype)
+        if (!PyArg_ParseTuple(outer_arg, "kl", &count, &owner))
+            return NULL;
+    
+    /* None is infinite, otherwise a float is the timeout in seconds, negative values
+     * are clipped to zero
+     */
+    if (timeout_obj == Py_None) {
+        microseconds = -1;
+    } else {
+        timeout = PyFloat_AsDouble(timeout_obj);
+        if (timeout == -1.0 && PyErr_Occurred())
+            goto ERR;
+        if (timeout > 0.0) {
+            timeout *= 1e6;
+            if (timeout >= (double) PY_TIMEOUT_MAX) {
+                PyErr_SetString(PyExc_OverflowError,
+                    "timeout value is too large");
+                goto ERR;
+            }
+            microseconds = (PY_TIMEOUT_T) timeout;
+        } else
+            microseconds = 0;
+    }
+
+    r = PY_LOCK_ACQUIRED;
+    goto ACQUIRE;
+ERR:
+    r = PY_LOCK_INTR; /* just acquire the outer lock and exit with error */
+ACQUIRE:
+    /* acquire the condition lock _and_ the outer lock before reacquiring the GIL */
+    Py_BEGIN_ALLOW_THREADS
+    if (r == PY_LOCK_ACQUIRED)
+        r = PyThread_acquire_lock_timed(self->lock_lock, microseconds, 1);
+    /* acquire the outer lock if we know it */
+    if (Py_TYPE(outer_lock) == &Locktype) {
+        PyThread_acquire_lock_timed(((lockobject*)outer_lock)->lock_lock, -1, 0);
+    } else if(Py_TYPE(outer_lock) == &RLocktype) {
+        rlockobject *rlock = (rlockobject*)outer_lock;
+        PyThread_acquire_lock_timed(rlock->rlock_lock, -1, 0);
+    }
+    Py_END_ALLOW_THREADS
+    /* and restore the state of the locks */
+    if (Py_TYPE(outer_lock) == &Locktype) {
+        ((lockobject*)outer_lock)->locked = 1;
+    } else if (Py_TYPE(outer_lock) == &RLocktype) {
+        rlockobject *rlock = (rlockobject*)outer_lock;
+        rlock->rlock_count = count;
+        rlock->rlock_owner = owner;
+    }
+
+    if (r == PY_LOCK_INTR) {
+        return NULL;
+    }
+
+    return PyBool_FromLong(r == PY_LOCK_ACQUIRED);
 }
 
 /* Thread-local objects */
 
 #include "structmember.h"
 
 /* Quick overview:
 
    We need to be able to reclaim reference cycles as soon as possible
    (both when a thread is being terminated, or a thread-local object
@@ skipping 765 matching lines @@
     nb_threads = 0;
 
     str_dict = PyUnicode_InternFromString("__dict__");
     if (str_dict == NULL)
         return NULL;
 
     /* Initialize the C thread library */
     PyThread_init_thread();
     return m;
 }