The PyCOND_TIMEDWAIT must use microseconds for the timeout argument

kristjanvalur · kristjanvalur · commit 33096fe8296b · 2014-05-08T10:36:27.000Z
in order to have the same resolution as pthreads condition variables. At the same time, it must be large enough to accept 31 bits of milliseconds, which is the maximum timeout value in the windows API. A PY_LONG_LONG of microseconds fullfills both requirements. This closes issue python#20737
diff --git a/Python/condvar.h b/Python/condvar.h
@@ -60,7 +60,7 @@
 #include <pthread.h>
 
 #define PyCOND_ADD_MICROSECONDS(tv, interval) \
-do { \
+do { /* TODO: add overflow and truncation checks */ \
     tv.tv_usec += (long) interval; \
     tv.tv_sec += tv.tv_usec / 1000000; \
     tv.tv_usec %= 1000000; \
@@ -89,7 +89,7 @@ do { \
 
 /* return 0 for success, 1 on timeout, -1 on error */
 Py_LOCAL_INLINE(int)
-PyCOND_TIMEDWAIT(PyCOND_T *cond, PyMUTEX_T *mut, long us)
+PyCOND_TIMEDWAIT(PyCOND_T *cond, PyMUTEX_T *mut, PY_LONG_LONG us)
 {
     int r;
     struct timespec ts;
@@ -270,9 +270,9 @@ PyCOND_WAIT(PyCOND_T *cv, PyMUTEX_T *cs)
 }
 
 Py_LOCAL_INLINE(int)
-PyCOND_TIMEDWAIT(PyCOND_T *cv, PyMUTEX_T *cs, long us)
+PyCOND_TIMEDWAIT(PyCOND_T *cv, PyMUTEX_T *cs, PY_LONG_LONG us)
 {
-    return _PyCOND_WAIT_MS(cv, cs, us/1000);
+    return _PyCOND_WAIT_MS(cv, cs, (DWORD)(us/1000));
 }
 
 Py_LOCAL_INLINE(int)
@@ -363,9 +363,9 @@ PyCOND_WAIT(PyCOND_T *cv, PyMUTEX_T *cs)
  * 2 to indicate that we don't know.
  */
 Py_LOCAL_INLINE(int)
-PyCOND_TIMEDWAIT(PyCOND_T *cv, PyMUTEX_T *cs, long us)
+PyCOND_TIMEDWAIT(PyCOND_T *cv, PyMUTEX_T *cs, PY_LONG_LONG us)
 {
-    return SleepConditionVariableSRW(cv, cs, us/1000, 0) ? 2 : -1;
+    return SleepConditionVariableSRW(cv, cs, (DWORD)(us/1000), 0) ? 2 : -1;
 }
 
 Py_LOCAL_INLINE(int)
diff --git a/Python/thread_nt.h b/Python/thread_nt.h
@@ -77,7 +77,7 @@ EnterNonRecursiveMutex(PNRMUTEX mutex, DWORD milliseconds)
         /* wait at least until the target */
         DWORD now, target = GetTickCount() + milliseconds;
         while (mutex->locked) {
-            if (PyCOND_TIMEDWAIT(&mutex->cv, &mutex->cs, milliseconds*1000) < 0) {
+            if (PyCOND_TIMEDWAIT(&mutex->cv, &mutex->cs, (PY_LONG_LONG)milliseconds*1000) < 0) {
                 result = WAIT_FAILED;
                 break;
             }

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@`
`60`	`60`	`#include <pthread.h>`
`61`	`61`
`62`	`62`	`#define PyCOND_ADD_MICROSECONDS(tv, interval) \`
`63`		`-do { \`
	`63`	`+do { /* TODO: add overflow and truncation checks */ \`
`64`	`64`	`tv.tv_usec += (long) interval; \`
`65`	`65`	`tv.tv_sec += tv.tv_usec / 1000000; \`
`66`	`66`	`tv.tv_usec %= 1000000; \`
`@@ -89,7 +89,7 @@ do { \`
`89`	`89`
`90`	`90`	`/* return 0 for success, 1 on timeout, -1 on error */`
`91`	`91`	`Py_LOCAL_INLINE(int)`
`92`		`-PyCOND_TIMEDWAIT(PyCOND_T cond, PyMUTEX_T mut, long us)`
	`92`	`+PyCOND_TIMEDWAIT(PyCOND_T cond, PyMUTEX_T mut, PY_LONG_LONG us)`
`93`	`93`	`{`
`94`	`94`	`int r;`
`95`	`95`	`struct timespec ts;`
`@@ -270,9 +270,9 @@ PyCOND_WAIT(PyCOND_T cv, PyMUTEX_T cs)`
`270`	`270`	`}`
`271`	`271`
`272`	`272`	`Py_LOCAL_INLINE(int)`
`273`		`-PyCOND_TIMEDWAIT(PyCOND_T cv, PyMUTEX_T cs, long us)`
	`273`	`+PyCOND_TIMEDWAIT(PyCOND_T cv, PyMUTEX_T cs, PY_LONG_LONG us)`
`274`	`274`	`{`
`275`		`- return _PyCOND_WAIT_MS(cv, cs, us/1000);`
	`275`	`+ return _PyCOND_WAIT_MS(cv, cs, (DWORD)(us/1000));`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`Py_LOCAL_INLINE(int)`
`@@ -363,9 +363,9 @@ PyCOND_WAIT(PyCOND_T cv, PyMUTEX_T cs)`
`363`	`363`	`* 2 to indicate that we don't know.`
`364`	`364`	`*/`
`365`	`365`	`Py_LOCAL_INLINE(int)`
`366`		`-PyCOND_TIMEDWAIT(PyCOND_T cv, PyMUTEX_T cs, long us)`
	`366`	`+PyCOND_TIMEDWAIT(PyCOND_T cv, PyMUTEX_T cs, PY_LONG_LONG us)`
`367`	`367`	`{`
`368`		`- return SleepConditionVariableSRW(cv, cs, us/1000, 0) ? 2 : -1;`
	`368`	`+ return SleepConditionVariableSRW(cv, cs, (DWORD)(us/1000), 0) ? 2 : -1;`
`369`	`369`	`}`
`370`	`370`
`371`	`371`	`Py_LOCAL_INLINE(int)`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ EnterNonRecursiveMutex(PNRMUTEX mutex, DWORD milliseconds)`
`77`	`77`	`/* wait at least until the target */`
`78`	`78`	`DWORD now, target = GetTickCount() + milliseconds;`
`79`	`79`	`while (mutex->locked) {`
`80`		`- if (PyCOND_TIMEDWAIT(&mutex->cv, &mutex->cs, milliseconds*1000) < 0) {`
	`80`	`+ if (PyCOND_TIMEDWAIT(&mutex->cv, &mutex->cs, (PY_LONG_LONG)milliseconds*1000) < 0) {`
`81`	`81`	`result = WAIT_FAILED;`
`82`	`82`	`break;`
`83`	`83`	`}`