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."
 #error "Then run `make clean' followed by `make'."
 #endif
 
 #include "pythread.h"
 
 static PyObject *ThreadError;
 static long nb_threads = 0;
 static PyObject *str_dict;
 
 /* Lock objects */
 
 typedef struct {
     PyObject_HEAD
     PyThread_type_lock lock_lock;
     PyObject *in_weakreflist;
+    char locked; /* for sanity checking */
 } lockobject;
 
 static void
 lock_dealloc(lockobject *self)
 {
     if (self->in_weakreflist != NULL)
         PyObject_ClearWeakRefs((PyObject *) self);
     if (self->lock_lock != NULL) {
         /* Unlock the lock so it's safe to free it */
-        PyThread_acquire_lock(self->lock_lock, 0);
-        PyThread_release_lock(self->lock_lock);
-
+        if (self->locked)
+            PyThread_release_lock(self->lock_lock);
         PyThread_free_lock(self->lock_lock);
     }
     PyObject_Del(self);
 }
 
 /* Helper to acquire an interruptible lock with a timeout.  If the lock acquire
  * is interrupted, signal handlers are run, and if they raise an exception,
  * PY_LOCK_INTR is returned.  Otherwise, PY_LOCK_ACQUIRED or PY_LOCK_FAILURE
  * are returned, depending on whether the lock can be acquired withing the
  * timeout.
  */
 static PyLockStatus
 acquire_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds)
 {
     PyLockStatus r;
     _PyTime_timeval curtime;
     _PyTime_timeval endtime;
 
 
     if (microseconds > 0) {
         _PyTime_gettimeofday(&endtime);
         endtime.tv_sec += microseconds / (1000 * 1000);
         endtime.tv_usec += microseconds % (1000 * 1000);
     }
 
 
     do {
-        Py_BEGIN_ALLOW_THREADS
-        r = PyThread_acquire_lock_timed(lock, microseconds, 1);
-        Py_END_ALLOW_THREADS
+        /* first a simple non-blocking try without releasing the GIL */
+        r = PyThread_acquire_lock_timed(lock, 0, 0);
+        if (r == PY_LOCK_FAILURE && microseconds != 0) {
+            Py_BEGIN_ALLOW_THREADS
+            r = PyThread_acquire_lock_timed(lock, microseconds, 1);
+            Py_END_ALLOW_THREADS
+        } 
 
         if (r == PY_LOCK_INTR) {
             /* Run signal handlers if we were interrupted.  Propagate
              * exceptions from signal handlers, such as KeyboardInterrupt, by
              * passing up PY_LOCK_INTR.  */
             if (Py_MakePendingCalls() < 0) {
                 return PY_LOCK_INTR;
             }
 
             /* If we're using a timeout, recompute the timeout after processing
@@ skipping 50 matching lines @@
             return NULL;
         }
         microseconds = (PY_TIMEOUT_T) timeout;
     }
 
     r = acquire_timed(self->lock_lock, microseconds);
     if (r == PY_LOCK_INTR) {
         return NULL;
     }
 
+    if (r == PY_LOCK_ACQUIRED)
+        self->locked = 1;
     return PyBool_FromLong(r == PY_LOCK_ACQUIRED);
 }
 
 PyDoc_STRVAR(acquire_doc,
 "acquire([wait]) -> None or bool\n\
 (acquire_lock() is an obsolete synonym)\n\
 \n\
 Lock the lock.  Without argument, this blocks if the lock is already\n\
 locked (even by the same thread), waiting for another thread to release\n\
 the lock, and return None once the lock is acquired.\n\
 With an argument, this will only block if the argument is true,\n\
 and the return value reflects whether the lock is acquired.\n\
 The blocking operation is interruptible.");
 
 static PyObject *
 lock_PyThread_release_lock(lockobject *self)
 {
     /* Sanity check: the lock must be locked */
-    if (PyThread_acquire_lock(self->lock_lock, 0)) {
-        PyThread_release_lock(self->lock_lock);
+    if (!self->locked) {
         PyErr_SetString(ThreadError, "release unlocked lock");
         return NULL;
     }
 
     PyThread_release_lock(self->lock_lock);
+    self->locked = 0;
     Py_INCREF(Py_None);
     return Py_None;
 }
 
 PyDoc_STRVAR(release_doc,
 "release()\n\
 (release_lock() is an obsolete synonym)\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\
 but it needn't be locked by the same thread that unlocks it.");
 
 static PyObject *
 lock_locked_lock(lockobject *self)
 {
-    if (PyThread_acquire_lock(self->lock_lock, 0)) {
-        PyThread_release_lock(self->lock_lock);
-        return PyBool_FromLong(0L);
-    }
-    return PyBool_FromLong(1L);
+    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\
@@ skipping 147 matching lines @@
     if (self->rlock_count > 0 && tid == self->rlock_owner) {
         unsigned long count = self->rlock_count + 1;
         if (count <= self->rlock_count) {
             PyErr_SetString(PyExc_OverflowError,
                             "Internal lock count overflowed");
             return NULL;
         }
         self->rlock_count = count;
         Py_RETURN_TRUE;
     }
-
-    if (self->rlock_count > 0 ||
-        !PyThread_acquire_lock(self->rlock_lock, 0)) {
-        if (microseconds == 0) {
-            Py_RETURN_FALSE;
-        }
-        r = acquire_timed(self->rlock_lock, microseconds);
-    }
+    r = acquire_timed(self->rlock_lock, microseconds);
     if (r == PY_LOCK_ACQUIRED) {
         assert(self->rlock_count == 0);
         self->rlock_owner = tid;
         self->rlock_count = 1;
     }
     else if (r == PY_LOCK_INTR) {
         return NULL;
     }
 
     return PyBool_FromLong(r == PY_LOCK_ACQUIRED);
@@ skipping 177 matching lines @@
 };
 
 static lockobject *
 newlockobject(void)
 {
     lockobject *self;
     self = PyObject_New(lockobject, &Locktype);
     if (self == NULL)
         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)
 {
-    double timeout;
+    PyObject *timeout_obj;
     PyObject *outer_lock;
     PyObject *outer_arg;
+    double timeout;
+    unsigned long count;
+    long owner;
     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)
+    /* 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 *= 1e6;
-        if (timeout >= (double) PY_TIMEOUT_MAX) {
-            PyErr_SetString(PyExc_OverflowError,
-                "timeout value is too large");
-            return NULL;
-        }
-        microseconds = (PY_TIMEOUT_T) timeout;
-    }
-
+    } 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
-    r = PyThread_acquire_lock_timed(self->lock_lock, microseconds, 1);
+    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 RLock */
-    if (Py_TYPE(outer_lock) == &RLocktype) {
+    /* 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;
-        PyArg_ParseTuple(outer_arg, "kl", &rlock->rlock_count, &rlock->rlock_owner);
+        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 */
@@ skipping 772 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;
 }