Showing the changes to sys/src/cmd/python/Python/thread_nt.h (1 of 3706 files). Show all
Unified · Split
| @@ -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) | ||