Recorded merge of revisions 81029 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines
Untabify C files. Will watch buildbots.
........
diff --git a/Python/thread_nt.h b/Python/thread_nt.h
index 9445529..7512c73 100644
--- a/Python/thread_nt.h
+++ b/Python/thread_nt.h
@@ -10,81 +10,81 @@
#endif
typedef struct NRMUTEX {
- LONG owned ;
- DWORD thread_id ;
- HANDLE hevent ;
+ LONG owned ;
+ DWORD thread_id ;
+ HANDLE hevent ;
} NRMUTEX, *PNRMUTEX ;
BOOL
InitializeNonRecursiveMutex(PNRMUTEX mutex)
{
- mutex->owned = -1 ; /* No threads have entered NonRecursiveMutex */
- mutex->thread_id = 0 ;
- mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
- return mutex->hevent != NULL ; /* TRUE if the mutex is created */
+ mutex->owned = -1 ; /* No threads have entered NonRecursiveMutex */
+ mutex->thread_id = 0 ;
+ mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
+ return mutex->hevent != NULL ; /* TRUE if the mutex is created */
}
VOID
DeleteNonRecursiveMutex(PNRMUTEX mutex)
{
- /* No in-use check */
- CloseHandle(mutex->hevent) ;
- mutex->hevent = NULL ; /* Just in case */
+ /* No in-use check */
+ CloseHandle(mutex->hevent) ;
+ mutex->hevent = NULL ; /* Just in case */
}
DWORD
EnterNonRecursiveMutex(PNRMUTEX mutex, BOOL wait)
{
- /* Assume that the thread waits successfully */
- DWORD ret ;
+ /* Assume that the thread waits successfully */
+ DWORD ret ;
- /* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
- if (!wait)
- {
- if (InterlockedCompareExchange(&mutex->owned, 0, -1) != -1)
- return WAIT_TIMEOUT ;
- ret = WAIT_OBJECT_0 ;
- }
- else
- ret = InterlockedIncrement(&mutex->owned) ?
- /* Some thread owns the mutex, let's wait... */
- WaitForSingleObject(mutex->hevent, INFINITE) : WAIT_OBJECT_0 ;
+ /* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
+ if (!wait)
+ {
+ if (InterlockedCompareExchange(&mutex->owned, 0, -1) != -1)
+ return WAIT_TIMEOUT ;
+ ret = WAIT_OBJECT_0 ;
+ }
+ else
+ ret = InterlockedIncrement(&mutex->owned) ?
+ /* Some thread owns the mutex, let's wait... */
+ WaitForSingleObject(mutex->hevent, INFINITE) : WAIT_OBJECT_0 ;
- mutex->thread_id = GetCurrentThreadId() ; /* We own it */
- return ret ;
+ mutex->thread_id = GetCurrentThreadId() ; /* We own it */
+ return ret ;
}
BOOL
LeaveNonRecursiveMutex(PNRMUTEX mutex)
{
- /* We don't own the mutex */
- mutex->thread_id = 0 ;
- return
- InterlockedDecrement(&mutex->owned) < 0 ||
- SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
+ /* We don't own the mutex */
+ mutex->thread_id = 0 ;
+ return
+ InterlockedDecrement(&mutex->owned) < 0 ||
+ SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
}
PNRMUTEX
AllocNonRecursiveMutex(void)
{
- PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
- if (mutex && !InitializeNonRecursiveMutex(mutex))
- {
- free(mutex) ;
- mutex = NULL ;
- }
- return mutex ;
+ PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
+ if (mutex && !InitializeNonRecursiveMutex(mutex))
+ {
+ free(mutex) ;
+ mutex = NULL ;
+ }
+ return mutex ;
}
void
FreeNonRecursiveMutex(PNRMUTEX mutex)
{
- if (mutex)
- {
- DeleteNonRecursiveMutex(mutex) ;
- free(mutex) ;
- }
+ if (mutex)
+ {
+ DeleteNonRecursiveMutex(mutex) ;
+ free(mutex) ;
+ }
}
long PyThread_get_thread_ident(void);
@@ -102,65 +102,65 @@
*/
typedef struct {
- void (*func)(void*);
- void *arg;
- long id;
- HANDLE done;
+ void (*func)(void*);
+ void *arg;
+ long id;
+ HANDLE done;
} callobj;
static int
bootstrap(void *call)
{
- callobj *obj = (callobj*)call;
- /* copy callobj since other thread might free it before we're done */
- void (*func)(void*) = obj->func;
- void *arg = obj->arg;
+ callobj *obj = (callobj*)call;
+ /* copy callobj since other thread might free it before we're done */
+ void (*func)(void*) = obj->func;
+ void *arg = obj->arg;
- obj->id = PyThread_get_thread_ident();
- ReleaseSemaphore(obj->done, 1, NULL);
- func(arg);
- return 0;
+ obj->id = PyThread_get_thread_ident();
+ ReleaseSemaphore(obj->done, 1, NULL);
+ func(arg);
+ return 0;
}
long
PyThread_start_new_thread(void (*func)(void *), void *arg)
{
- Py_uintptr_t rv;
- callobj obj;
+ Py_uintptr_t rv;
+ callobj obj;
- dprintf(("%ld: PyThread_start_new_thread called\n",
- PyThread_get_thread_ident()));
- if (!initialized)
- PyThread_init_thread();
+ dprintf(("%ld: PyThread_start_new_thread called\n",
+ PyThread_get_thread_ident()));
+ if (!initialized)
+ PyThread_init_thread();
- obj.id = -1; /* guilty until proved innocent */
- obj.func = func;
- obj.arg = arg;
- obj.done = CreateSemaphore(NULL, 0, 1, NULL);
- if (obj.done == NULL)
- return -1;
+ obj.id = -1; /* guilty until proved innocent */
+ obj.func = func;
+ obj.arg = arg;
+ obj.done = CreateSemaphore(NULL, 0, 1, NULL);
+ if (obj.done == NULL)
+ return -1;
- rv = _beginthread(bootstrap,
- Py_SAFE_DOWNCAST(_pythread_stacksize,
- Py_ssize_t, int),
- &obj);
- if (rv == (Py_uintptr_t)-1) {
- /* I've seen errno == EAGAIN here, which means "there are
- * too many threads".
- */
- dprintf(("%ld: PyThread_start_new_thread failed: %p errno %d\n",
- PyThread_get_thread_ident(), (void*)rv, errno));
- obj.id = -1;
- }
- else {
- dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
- PyThread_get_thread_ident(), (void*)rv));
- /* wait for thread to initialize, so we can get its id */
- WaitForSingleObject(obj.done, INFINITE);
- assert(obj.id != -1);
- }
- CloseHandle((HANDLE)obj.done);
- return obj.id;
+ rv = _beginthread(bootstrap,
+ Py_SAFE_DOWNCAST(_pythread_stacksize,
+ Py_ssize_t, int),
+ &obj);
+ if (rv == (Py_uintptr_t)-1) {
+ /* I've seen errno == EAGAIN here, which means "there are
+ * too many threads".
+ */
+ dprintf(("%ld: PyThread_start_new_thread failed: %p errno %d\n",
+ PyThread_get_thread_ident(), (void*)rv, errno));
+ obj.id = -1;
+ }
+ else {
+ dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
+ PyThread_get_thread_ident(), (void*)rv));
+ /* wait for thread to initialize, so we can get its id */
+ WaitForSingleObject(obj.done, INFINITE);
+ assert(obj.id != -1);
+ }
+ CloseHandle((HANDLE)obj.done);
+ return obj.id;
}
/*
@@ -170,58 +170,58 @@
long
PyThread_get_thread_ident(void)
{
- if (!initialized)
- PyThread_init_thread();
+ if (!initialized)
+ PyThread_init_thread();
- return GetCurrentThreadId();
+ return GetCurrentThreadId();
}
static void
do_PyThread_exit_thread(int no_cleanup)
{
- dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
- if (!initialized)
- if (no_cleanup)
- _exit(0);
- else
- exit(0);
- _endthread();
+ dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
+ if (!initialized)
+ if (no_cleanup)
+ _exit(0);
+ else
+ exit(0);
+ _endthread();
}
void
PyThread_exit_thread(void)
{
- do_PyThread_exit_thread(0);
+ do_PyThread_exit_thread(0);
}
void
PyThread__exit_thread(void)
{
- do_PyThread_exit_thread(1);
+ do_PyThread_exit_thread(1);
}
#ifndef NO_EXIT_PROG
static void
do_PyThread_exit_prog(int status, int no_cleanup)
{
- dprintf(("PyThread_exit_prog(%d) called\n", status));
- if (!initialized)
- if (no_cleanup)
- _exit(status);
- else
- exit(status);
+ dprintf(("PyThread_exit_prog(%d) called\n", status));
+ if (!initialized)
+ if (no_cleanup)
+ _exit(status);
+ else
+ exit(status);
}
void
PyThread_exit_prog(int status)
{
- do_PyThread_exit_prog(status, 0);
+ do_PyThread_exit_prog(status, 0);
}
void
PyThread__exit_prog(int status)
{
- do_PyThread_exit_prog(status, 1);
+ do_PyThread_exit_prog(status, 1);
}
#endif /* NO_EXIT_PROG */
@@ -233,25 +233,25 @@
PyThread_type_lock
PyThread_allocate_lock(void)
{
- PNRMUTEX aLock;
+ PNRMUTEX aLock;
- dprintf(("PyThread_allocate_lock called\n"));
- if (!initialized)
- PyThread_init_thread();
+ dprintf(("PyThread_allocate_lock called\n"));
+ if (!initialized)
+ PyThread_init_thread();
- aLock = AllocNonRecursiveMutex() ;
+ aLock = AllocNonRecursiveMutex() ;
- dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
+ dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
- return (PyThread_type_lock) aLock;
+ return (PyThread_type_lock) aLock;
}
void
PyThread_free_lock(PyThread_type_lock aLock)
{
- dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
+ dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
- FreeNonRecursiveMutex(aLock) ;
+ FreeNonRecursiveMutex(aLock) ;
}
/*
@@ -263,29 +263,29 @@
int
PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
{
- int success ;
+ int success ;
- dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
+ dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
- success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;
+ success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;
- dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
+ dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
- return success;
+ return success;
}
void
PyThread_release_lock(PyThread_type_lock aLock)
{
- dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
+ dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
- if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
- dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));
+ if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
+ dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));
}
/* minimum/maximum thread stack sizes supported */
-#define THREAD_MIN_STACKSIZE 0x8000 /* 32kB */
-#define THREAD_MAX_STACKSIZE 0x10000000 /* 256MB */
+#define THREAD_MIN_STACKSIZE 0x8000 /* 32kB */
+#define THREAD_MAX_STACKSIZE 0x10000000 /* 256MB */
/* set the thread stack size.
* Return 0 if size is valid, -1 otherwise.
@@ -293,19 +293,19 @@
static int
_pythread_nt_set_stacksize(size_t size)
{
- /* set to default */
- if (size == 0) {
- _pythread_stacksize = 0;
- return 0;
- }
+ /* set to default */
+ if (size == 0) {
+ _pythread_stacksize = 0;
+ return 0;
+ }
- /* valid range? */
- if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
- _pythread_stacksize = size;
- return 0;
- }
+ /* valid range? */
+ if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
+ _pythread_stacksize = size;
+ return 0;
+ }
- return -1;
+ return -1;
}
-#define THREAD_SET_STACKSIZE(x) _pythread_nt_set_stacksize(x)
+#define THREAD_SET_STACKSIZE(x) _pythread_nt_set_stacksize(x)