PageRenderTime 465ms CodeModel.GetById 261ms app.highlight 9ms RepoModel.GetById 192ms app.codeStats 0ms

/Python/thread_wince.h

http://unladen-swallow.googlecode.com/
C++ Header | 171 lines | 108 code | 35 blank | 28 comment | 17 complexity | 52564294cad799c29872a7ac412ad71f MD5 | raw file
  1
  2/* This code implemented by Mark Hammond (MHammond@skippinet.com.au) */
  3
  4#include <windows.h>
  5#include <limits.h>
  6#include <pydebug.h>
  7
  8long PyThread_get_thread_ident(void);
  9
 10/*
 11 * Change all headers to pure ANSI as no one will use K&R style on an
 12 * NT
 13 */
 14
 15/*
 16 * Initialization of the C package, should not be needed.
 17 */
 18static void PyThread__init_thread(void)
 19{
 20}
 21
 22/*
 23 * Thread support.
 24 */
 25long PyThread_start_new_thread(void (*func)(void *), void *arg)
 26{
 27	long rv;
 28	int success = -1;
 29
 30	dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));
 31	if (!initialized)
 32		PyThread_init_thread();
 33
 34	rv = _beginthread(func, 0, arg); /* use default stack size */
 35 
 36	if (rv != -1) {
 37		success = 0;
 38		dprintf(("%ld: PyThread_start_new_thread succeeded:\n", PyThread_get_thread_ident()));
 39	}
 40
 41	return success;
 42}
 43
 44/*
 45 * Return the thread Id instead of an handle. The Id is said to uniquely identify the
 46 * thread in the system
 47 */
 48long PyThread_get_thread_ident(void)
 49{
 50	if (!initialized)
 51		PyThread_init_thread();
 52        
 53	return GetCurrentThreadId();
 54}
 55
 56static void do_PyThread_exit_thread(int no_cleanup)
 57{
 58	dprintf(("%ld: do_PyThread_exit_thread called\n", PyThread_get_thread_ident()));
 59	if (!initialized)
 60		if (no_cleanup)
 61			exit(0); /* XXX - was _exit()!! */
 62		else
 63			exit(0);
 64	_endthread();
 65}
 66
 67void PyThread_exit_thread(void)
 68{
 69	do_PyThread_exit_thread(0);
 70}
 71
 72void PyThread__exit_thread(void)
 73{
 74	do_PyThread_exit_thread(1);
 75}
 76
 77#ifndef NO_EXIT_PROG
 78static void do_PyThread_exit_prog(int status, int no_cleanup)
 79{
 80	dprintf(("PyThread_exit_prog(%d) called\n", status));
 81	if (!initialized)
 82		if (no_cleanup)
 83			_exit(status);
 84		else
 85			exit(status);
 86}
 87
 88void PyThread_exit_prog(int status)
 89{
 90	do_PyThread_exit_prog(status, 0);
 91}
 92
 93void PyThread__exit_prog(int status)
 94{
 95	do_PyThread_exit_prog(status, 1);
 96}
 97#endif /* NO_EXIT_PROG */
 98
 99/*
100 * Lock support. It has to be implemented using Mutexes, as
101 * CE doesnt support semaphores.  Therefore we use some hacks to
102 * simulate the non reentrant requirements of Python locks
103 */
104PyThread_type_lock PyThread_allocate_lock(void)
105{
106    HANDLE aLock;
107
108    dprintf(("PyThread_allocate_lock called\n"));
109    if (!initialized)
110        PyThread_init_thread();
111
112    aLock = CreateEvent(NULL,           /* Security attributes      */
113                        0,              /* Manual-Reset               */
114						1,              /* Is initially signalled  */
115                        NULL);          /* Name of event            */
116
117    dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
118
119    return (PyThread_type_lock) aLock;
120}
121
122void PyThread_free_lock(PyThread_type_lock aLock)
123{
124    dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
125
126    CloseHandle(aLock);
127}
128
129/*
130 * Return 1 on success if the lock was acquired
131 *
132 * and 0 if the lock was not acquired. This means a 0 is returned
133 * if the lock has already been acquired by this thread!
134 */
135int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
136{
137    int success = 1;
138    DWORD waitResult;
139
140    dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
141
142#ifndef DEBUG
143    waitResult = WaitForSingleObject(aLock, (waitflag ? INFINITE : 0));
144#else
145	/* To aid in debugging, we regularly wake up.  This allows us to
146	break into the debugger */
147	while (TRUE) {
148		waitResult = WaitForSingleObject(aLock, waitflag ? 3000 : 0);
149		if (waitflag==0 || (waitflag && waitResult == WAIT_OBJECT_0))
150			break;
151	}
152#endif
153
154    if (waitResult != WAIT_OBJECT_0) {
155		success = 0;    /* We failed */
156    }
157
158	dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
159
160	return success;
161}
162
163void PyThread_release_lock(PyThread_type_lock aLock)
164{
165    dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
166
167    if (!SetEvent(aLock))
168        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
169}
170
171