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/pystate.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Python/pystate.c+632−0
@@ -0,0 +1,632 @@
1
2/* Thread and interpreter state structures and their interfaces */
3
4#include "Python.h"
5
6/* --------------------------------------------------------------------------
7CAUTION
8
9Always use malloc() and free() directly in this file. A number of these
10functions are advertised as safe to call when the GIL isn't held, and in
11a debug build Python redirects (e.g.) PyMem_NEW (etc) to Python's debugging
12obmalloc functions. Those aren't thread-safe (they rely on the GIL to avoid
13the expense of doing their own locking).
14-------------------------------------------------------------------------- */
15
16#ifdef HAVE_DLOPEN
17#ifdef HAVE_DLFCN_H
18#include <dlfcn.h>
19#endif
20#ifndef RTLD_LAZY
21#define RTLD_LAZY 1
22#endif
23#endif
24
25
26#ifdef WITH_THREAD
27#include "pythread.h"
28static PyThread_type_lock head_mutex = NULL; /* Protects interp->tstate_head */
29#define HEAD_INIT() (void)(head_mutex || (head_mutex = PyThread_allocate_lock()))
30#define HEAD_LOCK() PyThread_acquire_lock(head_mutex, WAIT_LOCK)
31#define HEAD_UNLOCK() PyThread_release_lock(head_mutex)
32
33#ifdef __cplusplus
34extern "C" {
35#endif
36
37/* The single PyInterpreterState used by this process'
38 GILState implementation
39*/
40static PyInterpreterState *autoInterpreterState = NULL;
41static int autoTLSkey = 0;
42#else
43#define HEAD_INIT() /* Nothing */
44#define HEAD_LOCK() /* Nothing */
45#define HEAD_UNLOCK() /* Nothing */
46#endif
47
48static PyInterpreterState *interp_head = NULL;
49
50PyThreadState *_PyThreadState_Current = NULL;
51PyThreadFrameGetter _PyThreadState_GetFrame = NULL;
52
53#ifdef WITH_THREAD
54static void _PyGILState_NoteThreadState(PyThreadState* tstate);
55#endif
56
57
58PyInterpreterState *
59PyInterpreterState_New(void)
60{
61 PyInterpreterState *interp = (PyInterpreterState *)
62 malloc(sizeof(PyInterpreterState));
63
64 if (interp != NULL) {
65 HEAD_INIT();
66#ifdef WITH_THREAD
67 if (head_mutex == NULL)
68 Py_FatalError("Can't initialize threads for interpreter");
69#endif
70 interp->modules = NULL;
71 interp->modules_reloading = NULL;
72 interp->sysdict = NULL;
73 interp->builtins = NULL;
74 interp->tstate_head = NULL;
75 interp->codec_search_path = NULL;
76 interp->codec_search_cache = NULL;
77 interp->codec_error_registry = NULL;
78#ifdef HAVE_DLOPEN
79#ifdef RTLD_NOW
80 interp->dlopenflags = RTLD_NOW;
81#else
82 interp->dlopenflags = RTLD_LAZY;
83#endif
84#endif
85#ifdef WITH_TSC
86 interp->tscdump = 0;
87#endif
88
89 HEAD_LOCK();
90 interp->next = interp_head;
91 interp_head = interp;
92 HEAD_UNLOCK();
93 }
94
95 return interp;
96}
97
98
99void
100PyInterpreterState_Clear(PyInterpreterState *interp)
101{
102 PyThreadState *p;
103 HEAD_LOCK();
104 for (p = interp->tstate_head; p != NULL; p = p->next)
105 PyThreadState_Clear(p);
106 HEAD_UNLOCK();
107 Py_CLEAR(interp->codec_search_path);
108 Py_CLEAR(interp->codec_search_cache);
109 Py_CLEAR(interp->codec_error_registry);
110 Py_CLEAR(interp->modules);
111 Py_CLEAR(interp->modules_reloading);
112 Py_CLEAR(interp->sysdict);
113 Py_CLEAR(interp->builtins);
114}
115
116
117static void
118zapthreads(PyInterpreterState *interp)
119{
120 PyThreadState *p;
121 /* No need to lock the mutex here because this should only happen
122 when the threads are all really dead (XXX famous last words). */
123 while ((p = interp->tstate_head) != NULL) {
124 PyThreadState_Delete(p);
125 }
126}
127
128
129void
130PyInterpreterState_Delete(PyInterpreterState *interp)
131{
132 PyInterpreterState **p;
133 zapthreads(interp);
134 HEAD_LOCK();
135 for (p = &interp_head; ; p = &(*p)->next) {
136 if (*p == NULL)
137 Py_FatalError(
138 "PyInterpreterState_Delete: invalid interp");
139 if (*p == interp)
140 break;
141 }
142 if (interp->tstate_head != NULL)
143 Py_FatalError("PyInterpreterState_Delete: remaining threads");
144 *p = interp->next;
145 HEAD_UNLOCK();
146 free(interp);
147}
148
149
150/* Default implementation for _PyThreadState_GetFrame */
151static struct _frame *
152threadstate_getframe(PyThreadState *self)
153{
154 return self->frame;
155}
156
157PyThreadState *
158PyThreadState_New(PyInterpreterState *interp)
159{
160 PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState));
161
162 if (_PyThreadState_GetFrame == NULL)
163 _PyThreadState_GetFrame = threadstate_getframe;
164
165 if (tstate != NULL) {
166 tstate->interp = interp;
167
168 tstate->frame = NULL;
169 tstate->recursion_depth = 0;
170 tstate->tracing = 0;
171 tstate->use_tracing = 0;
172 tstate->tick_counter = 0;
173 tstate->gilstate_counter = 0;
174 tstate->async_exc = NULL;
175#ifdef WITH_THREAD
176 tstate->thread_id = PyThread_get_thread_ident();
177#else
178 tstate->thread_id = 0;
179#endif
180
181 tstate->dict = NULL;
182
183 tstate->curexc_type = NULL;
184 tstate->curexc_value = NULL;
185 tstate->curexc_traceback = NULL;
186
187 tstate->exc_type = NULL;
188 tstate->exc_value = NULL;
189 tstate->exc_traceback = NULL;
190
191 tstate->c_profilefunc = NULL;
192 tstate->c_tracefunc = NULL;
193 tstate->c_profileobj = NULL;
194 tstate->c_traceobj = NULL;
195
196#ifdef WITH_THREAD
197 _PyGILState_NoteThreadState(tstate);
198#endif
199
200 HEAD_LOCK();
201 tstate->next = interp->tstate_head;
202 interp->tstate_head = tstate;
203 HEAD_UNLOCK();
204 }
205
206 return tstate;
207}
208
209
210void
211PyThreadState_Clear(PyThreadState *tstate)
212{
213 if (Py_VerboseFlag && tstate->frame != NULL)
214 fprintf(stderr,
215 "PyThreadState_Clear: warning: thread still has a frame\n");
216
217 Py_CLEAR(tstate->frame);
218
219 Py_CLEAR(tstate->dict);
220 Py_CLEAR(tstate->async_exc);
221
222 Py_CLEAR(tstate->curexc_type);
223 Py_CLEAR(tstate->curexc_value);
224 Py_CLEAR(tstate->curexc_traceback);
225
226 Py_CLEAR(tstate->exc_type);
227 Py_CLEAR(tstate->exc_value);
228 Py_CLEAR(tstate->exc_traceback);
229
230 tstate->c_profilefunc = NULL;
231 tstate->c_tracefunc = NULL;
232 Py_CLEAR(tstate->c_profileobj);
233 Py_CLEAR(tstate->c_traceobj);
234}
235
236
237/* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */
238static void
239tstate_delete_common(PyThreadState *tstate)
240{
241 PyInterpreterState *interp;
242 PyThreadState **p;
243 if (tstate == NULL)
244 Py_FatalError("PyThreadState_Delete: NULL tstate");
245 interp = tstate->interp;
246 if (interp == NULL)
247 Py_FatalError("PyThreadState_Delete: NULL interp");
248 HEAD_LOCK();
249 for (p = &interp->tstate_head; ; p = &(*p)->next) {
250 if (*p == NULL)
251 Py_FatalError(
252 "PyThreadState_Delete: invalid tstate");
253 if (*p == tstate)
254 break;
255 }
256 *p = tstate->next;
257 HEAD_UNLOCK();
258 free(tstate);
259}
260
261
262void
263PyThreadState_Delete(PyThreadState *tstate)
264{
265 if (tstate == _PyThreadState_Current)
266 Py_FatalError("PyThreadState_Delete: tstate is still current");
267 tstate_delete_common(tstate);
268#ifdef WITH_THREAD
269 if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate)
270 PyThread_delete_key_value(autoTLSkey);
271#endif /* WITH_THREAD */
272}
273
274
275#ifdef WITH_THREAD
276void
277PyThreadState_DeleteCurrent()
278{
279 PyThreadState *tstate = _PyThreadState_Current;
280 if (tstate == NULL)
281 Py_FatalError(
282 "PyThreadState_DeleteCurrent: no current tstate");
283 _PyThreadState_Current = NULL;
284 tstate_delete_common(tstate);
285 if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate)
286 PyThread_delete_key_value(autoTLSkey);
287 PyEval_ReleaseLock();
288}
289#endif /* WITH_THREAD */
290
291
292PyThreadState *
293PyThreadState_Get(void)
294{
295 if (_PyThreadState_Current == NULL)
296 Py_FatalError("PyThreadState_Get: no current thread");
297
298 return _PyThreadState_Current;
299}
300
301
302PyThreadState *
303PyThreadState_Swap(PyThreadState *newts)
304{
305 PyThreadState *oldts = _PyThreadState_Current;
306
307 _PyThreadState_Current = newts;
308 /* It should not be possible for more than one thread state
309 to be used for a thread. Check this the best we can in debug
310 builds.
311 */
312#if defined(Py_DEBUG) && defined(WITH_THREAD)
313 if (newts) {
314 /* This can be called from PyEval_RestoreThread(). Similar
315 to it, we need to ensure errno doesn't change.
316 */
317 int err = errno;
318 PyThreadState *check = PyGILState_GetThisThreadState();
319 if (check && check->interp == newts->interp && check != newts)
320 Py_FatalError("Invalid thread state for this thread");
321 errno = err;
322 }
323#endif
324 return oldts;
325}
326
327/* An extension mechanism to store arbitrary additional per-thread state.
328 PyThreadState_GetDict() returns a dictionary that can be used to hold such
329 state; the caller should pick a unique key and store its state there. If
330 PyThreadState_GetDict() returns NULL, an exception has *not* been raised
331 and the caller should assume no per-thread state is available. */
332
333PyObject *
334PyThreadState_GetDict(void)
335{
336 if (_PyThreadState_Current == NULL)
337 return NULL;
338
339 if (_PyThreadState_Current->dict == NULL) {
340 PyObject *d;
341 _PyThreadState_Current->dict = d = PyDict_New();
342 if (d == NULL)
343 PyErr_Clear();
344 }
345 return _PyThreadState_Current->dict;
346}
347
348
349/* Asynchronously raise an exception in a thread.
350 Requested by Just van Rossum and Alex Martelli.
351 To prevent naive misuse, you must write your own extension
352 to call this, or use ctypes. Must be called with the GIL held.
353 Returns the number of tstates modified (normally 1, but 0 if `id` didn't
354 match any known thread id). Can be called with exc=NULL to clear an
355 existing async exception. This raises no exceptions. */
356
357int
358PyThreadState_SetAsyncExc(long id, PyObject *exc) {
359 PyThreadState *tstate = PyThreadState_GET();
360 PyInterpreterState *interp = tstate->interp;
361 PyThreadState *p;
362
363 /* Although the GIL is held, a few C API functions can be called
364 * without the GIL held, and in particular some that create and
365 * destroy thread and interpreter states. Those can mutate the
366 * list of thread states we're traversing, so to prevent that we lock
367 * head_mutex for the duration.
368 */
369 HEAD_LOCK();
370 for (p = interp->tstate_head; p != NULL; p = p->next) {
371 if (p->thread_id == id) {
372 /* Tricky: we need to decref the current value
373 * (if any) in p->async_exc, but that can in turn
374 * allow arbitrary Python code to run, including
375 * perhaps calls to this function. To prevent
376 * deadlock, we need to release head_mutex before
377 * the decref.
378 */
379 PyObject *old_exc = p->async_exc;
380 Py_XINCREF(exc);
381 p->async_exc = exc;
382 HEAD_UNLOCK();
383 Py_XDECREF(old_exc);
384 return 1;
385 }
386 }
387 HEAD_UNLOCK();
388 return 0;
389}
390
391
392/* Routines for advanced debuggers, requested by David Beazley.
393 Don't use unless you know what you are doing! */
394
395PyInterpreterState *
396PyInterpreterState_Head(void)
397{
398 return interp_head;
399}
400
401PyInterpreterState *
402PyInterpreterState_Next(PyInterpreterState *interp) {
403 return interp->next;
404}
405
406PyThreadState *
407PyInterpreterState_ThreadHead(PyInterpreterState *interp) {
408 return interp->tstate_head;
409}
410
411PyThreadState *
412PyThreadState_Next(PyThreadState *tstate) {
413 return tstate->next;
414}
415
416/* The implementation of sys._current_frames(). This is intended to be
417 called with the GIL held, as it will be when called via
418 sys._current_frames(). It's possible it would work fine even without
419 the GIL held, but haven't thought enough about that.
420*/
421PyObject *
422_PyThread_CurrentFrames(void)
423{
424 PyObject *result;
425 PyInterpreterState *i;
426
427 result = PyDict_New();
428 if (result == NULL)
429 return NULL;
430
431 /* for i in all interpreters:
432 * for t in all of i's thread states:
433 * if t's frame isn't NULL, map t's id to its frame
434 * Because these lists can mutute even when the GIL is held, we
435 * need to grab head_mutex for the duration.
436 */
437 HEAD_LOCK();
438 for (i = interp_head; i != NULL; i = i->next) {
439 PyThreadState *t;
440 for (t = i->tstate_head; t != NULL; t = t->next) {
441 PyObject *id;
442 int stat;
443 struct _frame *frame = t->frame;
444 if (frame == NULL)
445 continue;
446 id = PyInt_FromLong(t->thread_id);
447 if (id == NULL)
448 goto Fail;
449 stat = PyDict_SetItem(result, id, (PyObject *)frame);
450 Py_DECREF(id);
451 if (stat < 0)
452 goto Fail;
453 }
454 }
455 HEAD_UNLOCK();
456 return result;
457
458 Fail:
459 HEAD_UNLOCK();
460 Py_DECREF(result);
461 return NULL;
462}
463
464/* Python "auto thread state" API. */
465#ifdef WITH_THREAD
466
467/* Keep this as a static, as it is not reliable! It can only
468 ever be compared to the state for the *current* thread.
469 * If not equal, then it doesn't matter that the actual
470 value may change immediately after comparison, as it can't
471 possibly change to the current thread's state.
472 * If equal, then the current thread holds the lock, so the value can't
473 change until we yield the lock.
474*/
475static int
476PyThreadState_IsCurrent(PyThreadState *tstate)
477{
478 /* Must be the tstate for this thread */
479 assert(PyGILState_GetThisThreadState()==tstate);
480 /* On Windows at least, simple reads and writes to 32 bit values
481 are atomic.
482 */
483 return tstate == _PyThreadState_Current;
484}
485
486/* Internal initialization/finalization functions called by
487 Py_Initialize/Py_Finalize
488*/
489void
490_PyGILState_Init(PyInterpreterState *i, PyThreadState *t)
491{
492 assert(i && t); /* must init with valid states */
493 autoTLSkey = PyThread_create_key();
494 autoInterpreterState = i;
495 assert(PyThread_get_key_value(autoTLSkey) == NULL);
496 assert(t->gilstate_counter == 0);
497
498 _PyGILState_NoteThreadState(t);
499}
500
501void
502_PyGILState_Fini(void)
503{
504 PyThread_delete_key(autoTLSkey);
505 autoTLSkey = 0;
506 autoInterpreterState = NULL;
507}
508
509/* When a thread state is created for a thread by some mechanism other than
510 PyGILState_Ensure, it's important that the GILState machinery knows about
511 it so it doesn't try to create another thread state for the thread (this is
512 a better fix for SF bug #1010677 than the first one attempted).
513*/
514static void
515_PyGILState_NoteThreadState(PyThreadState* tstate)
516{
517 /* If autoTLSkey is 0, this must be the very first threadstate created
518 in Py_Initialize(). Don't do anything for now (we'll be back here
519 when _PyGILState_Init is called). */
520 if (!autoTLSkey)
521 return;
522
523 /* Stick the thread state for this thread in thread local storage.
524
525 The only situation where you can legitimately have more than one
526 thread state for an OS level thread is when there are multiple
527 interpreters, when:
528
529 a) You shouldn't really be using the PyGILState_ APIs anyway,
530 and:
531
532 b) The slightly odd way PyThread_set_key_value works (see
533 comments by its implementation) means that the first thread
534 state created for that given OS level thread will "win",
535 which seems reasonable behaviour.
536 */
537 if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0)
538 Py_FatalError("Couldn't create autoTLSkey mapping");
539
540 /* PyGILState_Release must not try to delete this thread state. */
541 tstate->gilstate_counter = 1;
542}
543
544/* The public functions */
545PyThreadState *
546PyGILState_GetThisThreadState(void)
547{
548 if (autoInterpreterState == NULL || autoTLSkey == 0)
549 return NULL;
550 return (PyThreadState *)PyThread_get_key_value(autoTLSkey);
551}
552
553PyGILState_STATE
554PyGILState_Ensure(void)
555{
556 int current;
557 PyThreadState *tcur;
558 /* Note that we do not auto-init Python here - apart from
559 potential races with 2 threads auto-initializing, pep-311
560 spells out other issues. Embedders are expected to have
561 called Py_Initialize() and usually PyEval_InitThreads().
562 */
563 assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */
564 tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey);
565 if (tcur == NULL) {
566 /* Create a new thread state for this thread */
567 tcur = PyThreadState_New(autoInterpreterState);
568 if (tcur == NULL)
569 Py_FatalError("Couldn't create thread-state for new thread");
570 /* This is our thread state! We'll need to delete it in the
571 matching call to PyGILState_Release(). */
572 tcur->gilstate_counter = 0;
573 current = 0; /* new thread state is never current */
574 }
575 else
576 current = PyThreadState_IsCurrent(tcur);
577 if (current == 0)
578 PyEval_RestoreThread(tcur);
579 /* Update our counter in the thread-state - no need for locks:
580 - tcur will remain valid as we hold the GIL.
581 - the counter is safe as we are the only thread "allowed"
582 to modify this value
583 */
584 ++tcur->gilstate_counter;
585 return current ? PyGILState_LOCKED : PyGILState_UNLOCKED;
586}
587
588void
589PyGILState_Release(PyGILState_STATE oldstate)
590{
591 PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value(
592 autoTLSkey);
593 if (tcur == NULL)
594 Py_FatalError("auto-releasing thread-state, "
595 "but no thread-state for this thread");
596 /* We must hold the GIL and have our thread state current */
597 /* XXX - remove the check - the assert should be fine,
598 but while this is very new (April 2003), the extra check
599 by release-only users can't hurt.
600 */
601 if (! PyThreadState_IsCurrent(tcur))
602 Py_FatalError("This thread state must be current when releasing");
603 assert(PyThreadState_IsCurrent(tcur));
604 --tcur->gilstate_counter;
605 assert(tcur->gilstate_counter >= 0); /* illegal counter value */
606
607 /* If we're going to destroy this thread-state, we must
608 * clear it while the GIL is held, as destructors may run.
609 */
610 if (tcur->gilstate_counter == 0) {
611 /* can't have been locked when we created it */
612 assert(oldstate == PyGILState_UNLOCKED);
613 PyThreadState_Clear(tcur);
614 /* Delete the thread-state. Note this releases the GIL too!
615 * It's vital that the GIL be held here, to avoid shutdown
616 * races; see bugs 225673 and 1061968 (that nasty bug has a
617 * habit of coming back).
618 */
619 PyThreadState_DeleteCurrent();
620 }
621 /* Release the lock if necessary */
622 else if (oldstate == PyGILState_UNLOCKED)
623 PyEval_SaveThread();
624}
625
626#ifdef __cplusplus
627}
628#endif
629
630#endif /* WITH_THREAD */
631
632