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+/* --------------------------------------------------------------------------
7+CAUTION
8+
9+Always use malloc() and free() directly in this file. A number of these
10+functions are advertised as safe to call when the GIL isn't held, and in
11+a debug build Python redirects (e.g.) PyMem_NEW (etc) to Python's debugging
12+obmalloc functions. Those aren't thread-safe (they rely on the GIL to avoid
13+the 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"
28+static 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
34+extern "C" {
35+#endif
36+
37+/* The single PyInterpreterState used by this process'
38+ GILState implementation
39+*/
40+static PyInterpreterState *autoInterpreterState = NULL;
41+static int autoTLSkey = 0;
42+#else
43+#define HEAD_INIT() /* Nothing */
44+#define HEAD_LOCK() /* Nothing */
45+#define HEAD_UNLOCK() /* Nothing */
46+#endif
47+
48+static PyInterpreterState *interp_head = NULL;
49+
50+PyThreadState *_PyThreadState_Current = NULL;
51+PyThreadFrameGetter _PyThreadState_GetFrame = NULL;
52+
53+#ifdef WITH_THREAD
54+static void _PyGILState_NoteThreadState(PyThreadState* tstate);
55+#endif
56+
57+
58+PyInterpreterState *
59+PyInterpreterState_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+
99+void
100+PyInterpreterState_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+
117+static void
118+zapthreads(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+
129+void
130+PyInterpreterState_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 */
151+static struct _frame *
152+threadstate_getframe(PyThreadState *self)
153+{
154+ return self->frame;
155+}
156+
157+PyThreadState *
158+PyThreadState_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+
210+void
211+PyThreadState_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() */
238+static void
239+tstate_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+
262+void
263+PyThreadState_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
276+void
277+PyThreadState_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+
292+PyThreadState *
293+PyThreadState_Get(void)
294+{
295+ if (_PyThreadState_Current == NULL)
296+ Py_FatalError("PyThreadState_Get: no current thread");
297+
298+ return _PyThreadState_Current;
299+}
300+
301+
302+PyThreadState *
303+PyThreadState_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+
333+PyObject *
334+PyThreadState_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+
357+int
358+PyThreadState_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+
395+PyInterpreterState *
396+PyInterpreterState_Head(void)
397+{
398+ return interp_head;
399+}
400+
401+PyInterpreterState *
402+PyInterpreterState_Next(PyInterpreterState *interp) {
403+ return interp->next;
404+}
405+
406+PyThreadState *
407+PyInterpreterState_ThreadHead(PyInterpreterState *interp) {
408+ return interp->tstate_head;
409+}
410+
411+PyThreadState *
412+PyThreadState_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+*/
421+PyObject *
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+*/
475+static int
476+PyThreadState_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+*/
489+void
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+
501+void
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+*/
514+static 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 */
545+PyThreadState *
546+PyGILState_GetThisThreadState(void)
547+{
548+ if (autoInterpreterState == NULL || autoTLSkey == 0)
549+ return NULL;
550+ return (PyThreadState *)PyThread_get_key_value(autoTLSkey);
551+}
552+
553+PyGILState_STATE
554+PyGILState_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+
588+void
589+PyGILState_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+