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 169 matching lines @@
         return PyBool_FromLong(0L);
     }
     return PyBool_FromLong(1L);
 }
 
 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 152 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 47 matching lines @@
     if (self == NULL)
         return NULL;
     self->lock_lock = PyThread_allocate_lock();
     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)
+{
+    double timeout;
+    PyObject *outer_lock;
+    PyObject *outer_arg;
+    PY_TIMEOUT_T microseconds;
+    PyLockStatus r;
+
+    if (!PyArg_ParseTuple(args, "dOO:_acquire_condition", &timeout, &outer_lock, &outer_arg))
+        return NULL;
+
+    if (timeout < 0 && timeout != -1) {
+        PyErr_SetString(PyExc_ValueError, "timeout value must be "
+            "strictly positive");
+        return NULL;
+    }
+    if (timeout == -1)
+        microseconds = -1;
+    else {
+        timeout *= 1e6;
+        if (timeout >= (double) PY_TIMEOUT_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+                "timeout value is too large");
+            return NULL;
+        }
+        microseconds = (PY_TIMEOUT_T) timeout;
+    }
+
+    /* acquire the condition lock _and_ the outer lock before reacquiring the GIL */
+    Py_BEGIN_ALLOW_THREADS
+    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 RLock */
+    if (Py_TYPE(outer_lock) == &RLocktype) {
+        rlockobject *rlock = (rlockobject*)outer_lock;
+        PyArg_ParseTuple(outer_arg, "kl", &rlock->rlock_count, &rlock->rlock_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;
 }