Mercurial > cpython-lru_cache-weakref
annotate Python/thread_nt.h @ 5438:e926c331ebbf legacy-trunk
Instead of importing graminit.h whenever one of the three grammar 'root'
symbols is needed, define these in Python.h with a Py_ prefix.
| author | Guido van Rossum <guido@python.org> |
|---|---|
| date | Wed, 07 May 1997 17:46:13 +0000 |
| parents | 65d2d8e67da3 |
| children | 68f2d7704180 |
| rev | line source |
|---|---|
| 2152 | 1 /*********************************************************** |
| 2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam, | |
| 3 The Netherlands. | |
| 4 | |
| 5 All Rights Reserved | |
| 6 | |
|
4503
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
7 Permission to use, copy, modify, and distribute this software and its |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
8 documentation for any purpose and without fee is hereby granted, |
| 2152 | 9 provided that the above copyright notice appear in all copies and that |
|
4503
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
10 both that copyright notice and this permission notice appear in |
| 2152 | 11 supporting documentation, and that the names of Stichting Mathematisch |
|
4503
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
12 Centrum or CWI or Corporation for National Research Initiatives or |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
13 CNRI not be used in advertising or publicity pertaining to |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
14 distribution of the software without specific, written prior |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
15 permission. |
| 2152 | 16 |
|
4503
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
17 While CWI is the initial source for this software, a modified version |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
18 is made available by the Corporation for National Research Initiatives |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
19 (CNRI) at the Internet address ftp://ftp.python.org. |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
20 |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
|
65d2d8e67da3
New permission notice, includes CNRI.
Guido van Rossum <guido@python.org>
parents:
4371
diff
changeset
|
28 PERFORMANCE OF THIS SOFTWARE. |
| 2152 | 29 |
| 30 ******************************************************************/ | |
| 31 | |
| 32 /* This code implemented by Dag.Gruneau@elsa.preseco.comm.se */ | |
| 33 | |
| 34 #include "windows.h" | |
| 35 #include "limits.h" | |
| 36 | |
| 37 long get_thread_ident(void); | |
| 38 | |
| 39 /* | |
| 40 * Change all headers to pure ANSI as no one will use K&R style on an | |
| 41 * NT | |
| 42 */ | |
| 43 | |
| 44 /* | |
| 45 * Initialization of the C package, should not be needed. | |
| 46 */ | |
| 47 static void _init_thread(void) | |
| 48 { | |
| 49 } | |
| 50 | |
| 51 /* | |
| 52 * Thread support. | |
| 53 */ | |
| 54 int start_new_thread(void (*func)(void *), void *arg) | |
| 55 { | |
| 56 HANDLE aThread; | |
| 57 DWORD aThreadId; | |
| 58 | |
| 59 int success = 0; /* init not needed when SOLARIS_THREADS and */ | |
| 60 /* C_THREADS implemented properly */ | |
| 61 dprintf(("%ld: start_new_thread called\n", get_thread_ident())); | |
| 62 if (!initialized) | |
| 63 init_thread(); | |
| 64 | |
| 65 aThread = CreateThread( | |
| 66 NULL, /* No security attributes */ | |
| 67 0, /* use default stack size */ | |
| 68 (LPTHREAD_START_ROUTINE) func, /* thread function */ | |
| 69 (LPVOID) arg, /* argument to thread function */ | |
| 70 0, /* use the default creation flags */ | |
| 71 &aThreadId); /* returns the thread identifier */ | |
| 72 | |
| 73 if (aThread != NULL) { | |
| 74 CloseHandle(aThread); /* We do not want to have any zombies hanging around */ | |
| 75 success = 1; | |
| 76 dprintf(("%ld: start_new_thread succeeded: %ld\n", get_thread_ident(), aThreadId)); | |
| 77 } | |
| 78 | |
| 79 return success; | |
| 80 } | |
| 81 | |
| 82 /* | |
| 83 * Return the thread Id instead of an handle. The Id is said to uniquely identify the | |
| 84 * thread in the system | |
| 85 */ | |
| 86 long get_thread_ident(void) | |
| 87 { | |
| 88 if (!initialized) | |
| 89 init_thread(); | |
| 90 | |
| 91 return GetCurrentThreadId(); | |
| 92 } | |
| 93 | |
| 94 static void do_exit_thread(int no_cleanup) | |
| 95 { | |
| 96 dprintf(("%ld: exit_thread called\n", get_thread_ident())); | |
| 97 if (!initialized) | |
| 98 if (no_cleanup) | |
| 99 _exit(0); | |
| 100 else | |
| 101 exit(0); | |
| 102 ExitThread(0); | |
| 103 } | |
| 104 | |
| 105 void exit_thread(void) | |
| 106 { | |
| 107 do_exit_thread(0); | |
| 108 } | |
| 109 | |
| 110 void _exit_thread(void) | |
| 111 { | |
| 112 do_exit_thread(1); | |
| 113 } | |
| 114 | |
| 115 #ifndef NO_EXIT_PROG | |
| 116 static void do_exit_prog(int status, int no_cleanup) | |
| 117 { | |
| 118 dprintf(("exit_prog(%d) called\n", status)); | |
| 119 if (!initialized) | |
| 120 if (no_cleanup) | |
| 121 _exit(status); | |
| 122 else | |
| 123 exit(status); | |
| 124 } | |
| 125 | |
| 126 void exit_prog(int status) | |
| 127 { | |
| 128 do_exit_prog(status, 0); | |
| 129 } | |
| 130 | |
| 131 void _exit_prog _P1(int status) | |
| 132 { | |
| 133 do_exit_prog(status, 1); | |
| 134 } | |
| 135 #endif /* NO_EXIT_PROG */ | |
| 136 | |
| 137 /* | |
| 138 * Lock support. It has too be implemented as semaphores. | |
| 139 * I [Dag] tried to implement it with mutex but I could find a way to | |
| 140 * tell whether a thread already own the lock or not. | |
| 141 */ | |
| 142 type_lock allocate_lock(void) | |
| 143 { | |
| 144 HANDLE aLock; | |
| 145 | |
| 146 dprintf(("allocate_lock called\n")); | |
| 147 if (!initialized) | |
| 148 init_thread(); | |
| 149 | |
| 150 aLock = CreateSemaphore(NULL, /* Security attributes */ | |
| 151 1, /* Initial value */ | |
| 152 1, /* Maximum value */ | |
| 153 NULL); | |
| 154 /* Name of semaphore */ | |
| 155 | |
| 156 dprintf(("%ld: allocate_lock() -> %lx\n", get_thread_ident(), (long)aLock)); | |
| 157 | |
| 158 return (type_lock) aLock; | |
| 159 } | |
| 160 | |
| 161 void free_lock(type_lock aLock) | |
| 162 { | |
| 163 dprintf(("%ld: free_lock(%lx) called\n", get_thread_ident(),(long)aLock)); | |
| 164 | |
| 165 CloseHandle((HANDLE) aLock); | |
| 166 } | |
| 167 | |
| 168 /* | |
| 169 * Return 1 on success if the lock was acquired | |
| 170 * | |
| 171 * and 0 if the lock was not acquired. This means a 0 is returned | |
| 172 * if the lock has already been acquired by this thread! | |
| 173 */ | |
| 174 int acquire_lock(type_lock aLock, int waitflag) | |
| 175 { | |
| 176 int success = 1; | |
| 177 DWORD waitResult; | |
| 178 | |
| 179 dprintf(("%ld: acquire_lock(%lx, %d) called\n", get_thread_ident(),(long)aLock, waitflag)); | |
| 180 | |
| 181 waitResult = WaitForSingleObject((HANDLE) aLock, (waitflag == 1 ? INFINITE : 0)); | |
| 182 | |
| 183 if (waitResult != WAIT_OBJECT_0) { | |
| 184 success = 0; /* We failed */ | |
| 185 } | |
| 186 | |
| 187 dprintf(("%ld: acquire_lock(%lx, %d) -> %d\n", get_thread_ident(),(long)aLock, waitflag, success)); | |
| 188 | |
| 189 return success; | |
| 190 } | |
| 191 | |
| 192 void release_lock(type_lock aLock) | |
| 193 { | |
| 194 dprintf(("%ld: release_lock(%lx) called\n", get_thread_ident(),(long)aLock)); | |
| 195 | |
| 196 if (!ReleaseSemaphore( | |
| 197 (HANDLE) aLock, /* Handle of semaphore */ | |
| 198 1, /* increment count by one */ | |
| 199 NULL)) /* not interested in previous count */ | |
| 200 { | |
| 201 dprintf(("%ld: Could not release_lock(%lx) error: %l\n", get_thread_ident(), (long)aLock, GetLastError())); | |
| 202 } | |
| 203 } | |
| 204 | |
| 205 /* | |
| 206 * Semaphore support. | |
| 207 */ | |
| 208 type_sema allocate_sema(int value) | |
| 209 { | |
| 210 HANDLE aSemaphore; | |
| 211 | |
| 212 dprintf(("%ld: allocate_sema called\n", get_thread_ident())); | |
| 213 if (!initialized) | |
| 214 init_thread(); | |
| 215 | |
| 216 aSemaphore = CreateSemaphore( NULL, /* Security attributes */ | |
| 217 value, /* Initial value */ | |
| 218 INT_MAX, /* Maximum value */ | |
| 219 NULL); /* Name of semaphore */ | |
| 220 | |
| 221 dprintf(("%ld: allocate_sema() -> %lx\n", get_thread_ident(), (long)aSemaphore)); | |
| 222 | |
| 223 return (type_sema) aSemaphore; | |
| 224 } | |
| 225 | |
| 226 void free_sema(type_sema aSemaphore) | |
| 227 { | |
| 228 dprintf(("%ld: free_sema(%lx) called\n", get_thread_ident(), (long)aSemaphore)); | |
| 229 | |
| 230 CloseHandle((HANDLE) aSemaphore); | |
| 231 } | |
| 232 | |
|
4371
c277ee8c669c
Sjoerd's thread changes (including down_sema typo fix).
Guido van Rossum <guido@python.org>
parents:
2152
diff
changeset
|
233 /* |
|
c277ee8c669c
Sjoerd's thread changes (including down_sema typo fix).
Guido van Rossum <guido@python.org>
parents:
2152
diff
changeset
|
234 XXX must do something about waitflag |
|
c277ee8c669c
Sjoerd's thread changes (including down_sema typo fix).
Guido van Rossum <guido@python.org>
parents:
2152
diff
changeset
|
235 */ |
|
c277ee8c669c
Sjoerd's thread changes (including down_sema typo fix).
Guido van Rossum <guido@python.org>
parents:
2152
diff
changeset
|
236 int down_sema(type_sema aSemaphore, int waitflag) |
| 2152 | 237 { |
| 238 DWORD waitResult; | |
| 239 | |
| 240 dprintf(("%ld: down_sema(%lx) called\n", get_thread_ident(), (long)aSemaphore)); | |
| 241 | |
| 242 waitResult = WaitForSingleObject( (HANDLE) aSemaphore, INFINITE); | |
| 243 | |
| 244 dprintf(("%ld: down_sema(%lx) return: %l\n", get_thread_ident(),(long) aSemaphore, waitResult)); | |
|
4371
c277ee8c669c
Sjoerd's thread changes (including down_sema typo fix).
Guido van Rossum <guido@python.org>
parents:
2152
diff
changeset
|
245 return 0; |
| 2152 | 246 } |
| 247 | |
| 248 void up_sema(type_sema aSemaphore) | |
| 249 { | |
| 250 ReleaseSemaphore( | |
| 251 (HANDLE) aSemaphore, /* Handle of semaphore */ | |
| 252 1, /* increment count by one */ | |
| 253 NULL); /* not interested in previous count */ | |
| 254 | |
| 255 dprintf(("%ld: up_sema(%lx)\n", get_thread_ident(), (long)aSemaphore)); | |
| 256 } |