History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Python/thread_nt.h (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Python/thread_nt.h+364−0
@@ -0,0 +1,364 @@
1+
2+/* This code implemented by Dag.Gruneau@elsa.preseco.comm.se */
3+/* Fast NonRecursiveMutex support by Yakov Markovitch, markovitch@iso.ru */
4+/* Eliminated some memory leaks, gsw@agere.com */
5+
6+#include <windows.h>
7+#include <limits.h>
8+#ifdef HAVE_PROCESS_H
9+#include <process.h>
10+#endif
11+
12+typedef struct NRMUTEX {
13+ LONG owned ;
14+ DWORD thread_id ;
15+ HANDLE hevent ;
16+} NRMUTEX, *PNRMUTEX ;
17+
18+typedef PVOID WINAPI interlocked_cmp_xchg_t(PVOID *dest, PVOID exc, PVOID comperand) ;
19+
20+/* Sorry mate, but we haven't got InterlockedCompareExchange in Win95! */
21+static PVOID WINAPI
22+interlocked_cmp_xchg(PVOID *dest, PVOID exc, PVOID comperand)
23+{
24+ static LONG spinlock = 0 ;
25+ PVOID result ;
26+ DWORD dwSleep = 0;
27+
28+ /* Acqire spinlock (yielding control to other threads if cant aquire for the moment) */
29+ while(InterlockedExchange(&spinlock, 1))
30+ {
31+ // Using Sleep(0) can cause a priority inversion.
32+ // Sleep(0) only yields the processor if there's
33+ // another thread of the same priority that's
34+ // ready to run. If a high-priority thread is
35+ // trying to acquire the lock, which is held by
36+ // a low-priority thread, then the low-priority
37+ // thread may never get scheduled and hence never
38+ // free the lock. NT attempts to avoid priority
39+ // inversions by temporarily boosting the priority
40+ // of low-priority runnable threads, but the problem
41+ // can still occur if there's a medium-priority
42+ // thread that's always runnable. If Sleep(1) is used,
43+ // then the thread unconditionally yields the CPU. We
44+ // only do this for the second and subsequent even
45+ // iterations, since a millisecond is a long time to wait
46+ // if the thread can be scheduled in again sooner
47+ // (~100,000 instructions).
48+ // Avoid priority inversion: 0, 1, 0, 1,...
49+ Sleep(dwSleep);
50+ dwSleep = !dwSleep;
51+ }
52+ result = *dest ;
53+ if (result == comperand)
54+ *dest = exc ;
55+ /* Release spinlock */
56+ spinlock = 0 ;
57+ return result ;
58+} ;
59+
60+static interlocked_cmp_xchg_t *ixchg;
61+
62+BOOL
63+InitializeNonRecursiveMutex(PNRMUTEX mutex)
64+{
65+ if (!ixchg)
66+ {
67+ /* Sorely, Win95 has no InterlockedCompareExchange API (Win98 has), so we have to use emulation */
68+ HANDLE kernel = GetModuleHandle("kernel32.dll") ;
69+ if (!kernel || (ixchg = (interlocked_cmp_xchg_t *)GetProcAddress(kernel, "InterlockedCompareExchange")) == NULL)
70+ ixchg = interlocked_cmp_xchg ;
71+ }
72+
73+ mutex->owned = -1 ; /* No threads have entered NonRecursiveMutex */
74+ mutex->thread_id = 0 ;
75+ mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
76+ return mutex->hevent != NULL ; /* TRUE if the mutex is created */
77+}
78+
79+#ifdef InterlockedCompareExchange
80+#undef InterlockedCompareExchange
81+#endif
82+#define InterlockedCompareExchange(dest,exchange,comperand) (ixchg((dest), (exchange), (comperand)))
83+
84+VOID
85+DeleteNonRecursiveMutex(PNRMUTEX mutex)
86+{
87+ /* No in-use check */
88+ CloseHandle(mutex->hevent) ;
89+ mutex->hevent = NULL ; /* Just in case */
90+}
91+
92+DWORD
93+EnterNonRecursiveMutex(PNRMUTEX mutex, BOOL wait)
94+{
95+ /* Assume that the thread waits successfully */
96+ DWORD ret ;
97+
98+ /* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
99+ if (!wait)
100+ {
101+ if (InterlockedCompareExchange((PVOID *)&mutex->owned, (PVOID)0, (PVOID)-1) != (PVOID)-1)
102+ return WAIT_TIMEOUT ;
103+ ret = WAIT_OBJECT_0 ;
104+ }
105+ else
106+ ret = InterlockedIncrement(&mutex->owned) ?
107+ /* Some thread owns the mutex, let's wait... */
108+ WaitForSingleObject(mutex->hevent, INFINITE) : WAIT_OBJECT_0 ;
109+
110+ mutex->thread_id = GetCurrentThreadId() ; /* We own it */
111+ return ret ;
112+}
113+
114+BOOL
115+LeaveNonRecursiveMutex(PNRMUTEX mutex)
116+{
117+ /* We don't own the mutex */
118+ mutex->thread_id = 0 ;
119+ return
120+ InterlockedDecrement(&mutex->owned) < 0 ||
121+ SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
122+}
123+
124+PNRMUTEX
125+AllocNonRecursiveMutex(void)
126+{
127+ PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
128+ if (mutex && !InitializeNonRecursiveMutex(mutex))
129+ {
130+ free(mutex) ;
131+ mutex = NULL ;
132+ }
133+ return mutex ;
134+}
135+
136+void
137+FreeNonRecursiveMutex(PNRMUTEX mutex)
138+{
139+ if (mutex)
140+ {
141+ DeleteNonRecursiveMutex(mutex) ;
142+ free(mutex) ;
143+ }
144+}
145+
146+long PyThread_get_thread_ident(void);
147+
148+/*
149+ * Initialization of the C package, should not be needed.
150+ */
151+static void
152+PyThread__init_thread(void)
153+{
154+}
155+
156+/*
157+ * Thread support.
158+ */
159+
160+typedef struct {
161+ void (*func)(void*);
162+ void *arg;
163+ long id;
164+ HANDLE done;
165+} callobj;
166+
167+static int
168+bootstrap(void *call)
169+{
170+ callobj *obj = (callobj*)call;
171+ /* copy callobj since other thread might free it before we're done */
172+ void (*func)(void*) = obj->func;
173+ void *arg = obj->arg;
174+
175+ obj->id = PyThread_get_thread_ident();
176+ ReleaseSemaphore(obj->done, 1, NULL);
177+ func(arg);
178+ return 0;
179+}
180+
181+long
182+PyThread_start_new_thread(void (*func)(void *), void *arg)
183+{
184+ Py_uintptr_t rv;
185+ callobj obj;
186+
187+ dprintf(("%ld: PyThread_start_new_thread called\n",
188+ PyThread_get_thread_ident()));
189+ if (!initialized)
190+ PyThread_init_thread();
191+
192+ obj.id = -1; /* guilty until proved innocent */
193+ obj.func = func;
194+ obj.arg = arg;
195+ obj.done = CreateSemaphore(NULL, 0, 1, NULL);
196+ if (obj.done == NULL)
197+ return -1;
198+
199+ rv = _beginthread(bootstrap, _pythread_stacksize, &obj);
200+ if (rv == (Py_uintptr_t)-1) {
201+ /* I've seen errno == EAGAIN here, which means "there are
202+ * too many threads".
203+ */
204+ dprintf(("%ld: PyThread_start_new_thread failed: %p errno %d\n",
205+ PyThread_get_thread_ident(), rv, errno));
206+ obj.id = -1;
207+ }
208+ else {
209+ dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
210+ PyThread_get_thread_ident(), rv));
211+ /* wait for thread to initialize, so we can get its id */
212+ WaitForSingleObject(obj.done, INFINITE);
213+ assert(obj.id != -1);
214+ }
215+ CloseHandle((HANDLE)obj.done);
216+ return obj.id;
217+}
218+
219+/*
220+ * Return the thread Id instead of an handle. The Id is said to uniquely identify the
221+ * thread in the system
222+ */
223+long
224+PyThread_get_thread_ident(void)
225+{
226+ if (!initialized)
227+ PyThread_init_thread();
228+
229+ return GetCurrentThreadId();
230+}
231+
232+static void
233+do_PyThread_exit_thread(int no_cleanup)
234+{
235+ dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
236+ if (!initialized)
237+ if (no_cleanup)
238+ _exit(0);
239+ else
240+ exit(0);
241+ _endthread();
242+}
243+
244+void
245+PyThread_exit_thread(void)
246+{
247+ do_PyThread_exit_thread(0);
248+}
249+
250+void
251+PyThread__exit_thread(void)
252+{
253+ do_PyThread_exit_thread(1);
254+}
255+
256+#ifndef NO_EXIT_PROG
257+static void
258+do_PyThread_exit_prog(int status, int no_cleanup)
259+{
260+ dprintf(("PyThread_exit_prog(%d) called\n", status));
261+ if (!initialized)
262+ if (no_cleanup)
263+ _exit(status);
264+ else
265+ exit(status);
266+}
267+
268+void
269+PyThread_exit_prog(int status)
270+{
271+ do_PyThread_exit_prog(status, 0);
272+}
273+
274+void
275+PyThread__exit_prog(int status)
276+{
277+ do_PyThread_exit_prog(status, 1);
278+}
279+#endif /* NO_EXIT_PROG */
280+
281+/*
282+ * Lock support. It has too be implemented as semaphores.
283+ * I [Dag] tried to implement it with mutex but I could find a way to
284+ * tell whether a thread already own the lock or not.
285+ */
286+PyThread_type_lock
287+PyThread_allocate_lock(void)
288+{
289+ PNRMUTEX aLock;
290+
291+ dprintf(("PyThread_allocate_lock called\n"));
292+ if (!initialized)
293+ PyThread_init_thread();
294+
295+ aLock = AllocNonRecursiveMutex() ;
296+
297+ dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
298+
299+ return (PyThread_type_lock) aLock;
300+}
301+
302+void
303+PyThread_free_lock(PyThread_type_lock aLock)
304+{
305+ dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
306+
307+ FreeNonRecursiveMutex(aLock) ;
308+}
309+
310+/*
311+ * Return 1 on success if the lock was acquired
312+ *
313+ * and 0 if the lock was not acquired. This means a 0 is returned
314+ * if the lock has already been acquired by this thread!
315+ */
316+int
317+PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
318+{
319+ int success ;
320+
321+ dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
322+
323+ success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;
324+
325+ dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
326+
327+ return success;
328+}
329+
330+void
331+PyThread_release_lock(PyThread_type_lock aLock)
332+{
333+ dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
334+
335+ if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
336+ dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
337+}
338+
339+/* minimum/maximum thread stack sizes supported */
340+#define THREAD_MIN_STACKSIZE 0x8000 /* 32kB */
341+#define THREAD_MAX_STACKSIZE 0x10000000 /* 256MB */
342+
343+/* set the thread stack size.
344+ * Return 0 if size is valid, -1 otherwise.
345+ */
346+static int
347+_pythread_nt_set_stacksize(size_t size)
348+{
349+ /* set to default */
350+ if (size == 0) {
351+ _pythread_stacksize = 0;
352+ return 0;
353+ }
354+
355+ /* valid range? */
356+ if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
357+ _pythread_stacksize = size;
358+ return 0;
359+ }
360+
361+ return -1;
362+}
363+
364+#define THREAD_SET_STACKSIZE(x) _pythread_nt_set_stacksize(x)