Mercurial > cpython-lru_cache-weakref
annotate Python/pystate.c @ 48167:a8a8232cb541 legacy-trunk
Adds a sanity check to avoid a *very rare* infinite loop due to a corrupt tls
key list data structure in the thread startup path.
This change is a companion to r60148 which already successfully dealt with a
similar issue on thread shutdown.
In particular this loop has been observed happening from this call path:
#0 in find_key ()
#1 in PyThread_set_key_value ()
#2 in _PyGILState_NoteThreadState ()
#3 in PyThreadState_New ()
#4 in t_bootstrap ()
#5 in pthread_start_thread ()
I don't know how this happens but it does, *very* rarely. On more than
one hardware platform. I have not been able to reproduce it manually.
(A flaky mutex implementation on the system in question is one hypothesis).
As with r60148, the spinning we managed to observe in the wild was due to a
single list element pointing back upon itself.
| author | Gregory P. Smith <greg@mad-scientist.com> |
|---|---|
| date | Mon, 04 Aug 2008 07:33:37 +0000 |
| parents | eb2eafda29b7 |
| children | 7f500641c06a |
| rev | line source |
|---|---|
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
1 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
2 /* Thread and interpreter state structures and their interfaces */ |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
3 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
4 #include "Python.h" |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
5 |
|
33713
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
6 /* -------------------------------------------------------------------------- |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
7 CAUTION |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
8 |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
9 Always use malloc() and free() directly in this file. A number of these |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
10 functions are advertised as safe to call when the GIL isn't held, and in |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
11 a debug build Python redirects (e.g.) PyMem_NEW (etc) to Python's debugging |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
12 obmalloc functions. Those aren't thread-safe (they rely on the GIL to avoid |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
13 the expense of doing their own locking). |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
14 -------------------------------------------------------------------------- */ |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
15 |
|
18689
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
16 #ifdef HAVE_DLOPEN |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
17 #ifdef HAVE_DLFCN_H |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
18 #include <dlfcn.h> |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
19 #endif |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
20 #ifndef RTLD_LAZY |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
21 #define RTLD_LAZY 1 |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
22 #endif |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
23 #endif |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
24 |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
25 |
| 11011 | 26 #ifdef WITH_THREAD |
| 27 #include "pythread.h" | |
| 28 static PyThread_type_lock head_mutex = NULL; /* Protects interp->tstate_head */ | |
|
13866
dfdb601cee1c
Removing warnings by gcc -Wall -- cast ugly || to void.
Moshe Zadka <moshez@math.huji.ac.il>
parents:
13658
diff
changeset
|
29 #define HEAD_INIT() (void)(head_mutex || (head_mutex = PyThread_allocate_lock())) |
| 11011 | 30 #define HEAD_LOCK() PyThread_acquire_lock(head_mutex, WAIT_LOCK) |
| 31 #define HEAD_UNLOCK() PyThread_release_lock(head_mutex) | |
| 35117 | 32 |
|
37655
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
33 #ifdef __cplusplus |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
34 extern "C" { |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
35 #endif |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
36 |
| 35117 | 37 /* The single PyInterpreterState used by this process' |
| 38 GILState implementation | |
| 39 */ | |
| 40 static PyInterpreterState *autoInterpreterState = NULL; | |
| 41 static int autoTLSkey = 0; | |
| 11011 | 42 #else |
| 43 #define HEAD_INIT() /* Nothing */ | |
| 44 #define HEAD_LOCK() /* Nothing */ | |
| 45 #define HEAD_UNLOCK() /* Nothing */ | |
| 46 #endif | |
| 47 | |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
48 static PyInterpreterState *interp_head = NULL; |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
49 |
|
9667
914f83e7fa0a
Make current_tstate a global, _PyThreadState_Current. This is to
Guido van Rossum <guido@python.org>
parents:
7970
diff
changeset
|
50 PyThreadState *_PyThreadState_Current = NULL; |
|
27978
4b99a701defe
- PyEval_GetFrame() is now declared to return a PyFrameObject *
Guido van Rossum <guido@python.org>
parents:
26109
diff
changeset
|
51 PyThreadFrameGetter _PyThreadState_GetFrame = NULL; |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
52 |
| 35661 | 53 #ifdef WITH_THREAD |
| 35117 | 54 static void _PyGILState_NoteThreadState(PyThreadState* tstate); |
| 35661 | 55 #endif |
| 35117 | 56 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
57 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
58 PyInterpreterState * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13256
diff
changeset
|
59 PyInterpreterState_New(void) |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
60 { |
|
33713
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
61 PyInterpreterState *interp = (PyInterpreterState *) |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
62 malloc(sizeof(PyInterpreterState)); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
63 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
64 if (interp != NULL) { |
| 11011 | 65 HEAD_INIT(); |
|
39129
f2031f15d99d
Handle allocation failures gracefully. Found with failmalloc.
Neal Norwitz <nnorwitz@gmail.com>
parents:
39118
diff
changeset
|
66 #ifdef WITH_THREAD |
|
f2031f15d99d
Handle allocation failures gracefully. Found with failmalloc.
Neal Norwitz <nnorwitz@gmail.com>
parents:
39118
diff
changeset
|
67 if (head_mutex == NULL) |
|
f2031f15d99d
Handle allocation failures gracefully. Found with failmalloc.
Neal Norwitz <nnorwitz@gmail.com>
parents:
39118
diff
changeset
|
68 Py_FatalError("Can't initialize threads for interpreter"); |
|
f2031f15d99d
Handle allocation failures gracefully. Found with failmalloc.
Neal Norwitz <nnorwitz@gmail.com>
parents:
39118
diff
changeset
|
69 #endif |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
70 interp->modules = NULL; |
|
41128
45ce388ec59a
Bug #742342: make Python stop segfaulting on infinitely-recursive reload()s. Fixed by patch #922167.
Collin Winter <collinw@gmail.com>
parents:
39875
diff
changeset
|
71 interp->modules_reloading = NULL; |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
72 interp->sysdict = NULL; |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
73 interp->builtins = NULL; |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
74 interp->tstate_head = NULL; |
|
28325
850626d47574
Fixed SF bug #663074. The codec system was using global static
Gustavo Niemeyer <gustavo@niemeyer.net>
parents:
27978
diff
changeset
|
75 interp->codec_search_path = NULL; |
|
850626d47574
Fixed SF bug #663074. The codec system was using global static
Gustavo Niemeyer <gustavo@niemeyer.net>
parents:
27978
diff
changeset
|
76 interp->codec_search_cache = NULL; |
|
850626d47574
Fixed SF bug #663074. The codec system was using global static
Gustavo Niemeyer <gustavo@niemeyer.net>
parents:
27978
diff
changeset
|
77 interp->codec_error_registry = NULL; |
|
18689
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
78 #ifdef HAVE_DLOPEN |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
79 #ifdef RTLD_NOW |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
80 interp->dlopenflags = RTLD_NOW; |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
81 #else |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
82 interp->dlopenflags = RTLD_LAZY; |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
83 #endif |
|
064de84385ca
Patch #412229: Add functions sys.getdlopenflags and sys.setdlopenflags.
Martin v. Löwis <martin@v.loewis.de>
parents:
18374
diff
changeset
|
84 #endif |
|
32301
41c59d80bbc5
Patch #510695: Add TSC profiling for the VM.
Martin v. Löwis <martin@v.loewis.de>
parents:
31797
diff
changeset
|
85 #ifdef WITH_TSC |
|
41c59d80bbc5
Patch #510695: Add TSC profiling for the VM.
Martin v. Löwis <martin@v.loewis.de>
parents:
31797
diff
changeset
|
86 interp->tscdump = 0; |
|
41c59d80bbc5
Patch #510695: Add TSC profiling for the VM.
Martin v. Löwis <martin@v.loewis.de>
parents:
31797
diff
changeset
|
87 #endif |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
88 |
|
14378
ca7316a00464
PyInterpreterState_New is not thread-safe, and the recent fix to _PyPclose
Tim Peters <tim.peters@gmail.com>
parents:
14375
diff
changeset
|
89 HEAD_LOCK(); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
90 interp->next = interp_head; |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
91 interp_head = interp; |
|
14378
ca7316a00464
PyInterpreterState_New is not thread-safe, and the recent fix to _PyPclose
Tim Peters <tim.peters@gmail.com>
parents:
14375
diff
changeset
|
92 HEAD_UNLOCK(); |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
93 } |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
94 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
95 return interp; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
96 } |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
97 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
98 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
99 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13256
diff
changeset
|
100 PyInterpreterState_Clear(PyInterpreterState *interp) |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
101 { |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
102 PyThreadState *p; |
| 11011 | 103 HEAD_LOCK(); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
104 for (p = interp->tstate_head; p != NULL; p = p->next) |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
105 PyThreadState_Clear(p); |
| 11011 | 106 HEAD_UNLOCK(); |
| 37752 | 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); | |
|
41128
45ce388ec59a
Bug #742342: make Python stop segfaulting on infinitely-recursive reload()s. Fixed by patch #922167.
Collin Winter <collinw@gmail.com>
parents:
39875
diff
changeset
|
111 Py_CLEAR(interp->modules_reloading); |
| 37752 | 112 Py_CLEAR(interp->sysdict); |
| 113 Py_CLEAR(interp->builtins); | |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
114 } |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
115 |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
116 |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
117 static void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13256
diff
changeset
|
118 zapthreads(PyInterpreterState *interp) |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
119 { |
| 11011 | 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) { | |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
124 PyThreadState_Delete(p); |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
125 } |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
126 } |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
127 |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
128 |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
129 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13256
diff
changeset
|
130 PyInterpreterState_Delete(PyInterpreterState *interp) |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
131 { |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
132 PyInterpreterState **p; |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
133 zapthreads(interp); |
|
14378
ca7316a00464
PyInterpreterState_New is not thread-safe, and the recent fix to _PyPclose
Tim Peters <tim.peters@gmail.com>
parents:
14375
diff
changeset
|
134 HEAD_LOCK(); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
135 for (p = &interp_head; ; p = &(*p)->next) { |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
136 if (*p == NULL) |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
137 Py_FatalError( |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
138 "PyInterpreterState_Delete: invalid interp"); |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
139 if (*p == interp) |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
140 break; |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
141 } |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
142 if (interp->tstate_head != NULL) |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
143 Py_FatalError("PyInterpreterState_Delete: remaining threads"); |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
144 *p = interp->next; |
|
14378
ca7316a00464
PyInterpreterState_New is not thread-safe, and the recent fix to _PyPclose
Tim Peters <tim.peters@gmail.com>
parents:
14375
diff
changeset
|
145 HEAD_UNLOCK(); |
|
33713
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
146 free(interp); |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
147 } |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
148 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
149 |
|
26109
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
150 /* Default implementation for _PyThreadState_GetFrame */ |
|
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
151 static struct _frame * |
|
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
152 threadstate_getframe(PyThreadState *self) |
|
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
153 { |
|
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
154 return self->frame; |
|
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
155 } |
|
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
156 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
157 PyThreadState * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13256
diff
changeset
|
158 PyThreadState_New(PyInterpreterState *interp) |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
159 { |
|
33713
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
160 PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState)); |
|
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
161 |
|
26109
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
162 if (_PyThreadState_GetFrame == NULL) |
|
27978
4b99a701defe
- PyEval_GetFrame() is now declared to return a PyFrameObject *
Guido van Rossum <guido@python.org>
parents:
26109
diff
changeset
|
163 _PyThreadState_GetFrame = threadstate_getframe; |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
164 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
165 if (tstate != NULL) { |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
166 tstate->interp = interp; |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
167 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
168 tstate->frame = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
169 tstate->recursion_depth = 0; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
170 tstate->tracing = 0; |
|
18374
3b295ce2705f
This change adjusts the profiling/tracing support so that the common
Fred Drake <fdrake@acm.org>
parents:
18326
diff
changeset
|
171 tstate->use_tracing = 0; |
|
26109
e61b946474df
Assorted patches from Armin Rigo:
Michael W. Hudson <mwh@python.net>
parents:
25111
diff
changeset
|
172 tstate->tick_counter = 0; |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
173 tstate->gilstate_counter = 0; |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
174 tstate->async_exc = NULL; |
|
29842
014cc362aa91
Initialize thread_id to 0 in unthreaded build. Fixes #770247.
Martin v. Löwis <martin@v.loewis.de>
parents:
29643
diff
changeset
|
175 #ifdef WITH_THREAD |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
176 tstate->thread_id = PyThread_get_thread_ident(); |
|
29842
014cc362aa91
Initialize thread_id to 0 in unthreaded build. Fixes #770247.
Martin v. Löwis <martin@v.loewis.de>
parents:
29643
diff
changeset
|
177 #else |
|
014cc362aa91
Initialize thread_id to 0 in unthreaded build. Fixes #770247.
Martin v. Löwis <martin@v.loewis.de>
parents:
29643
diff
changeset
|
178 tstate->thread_id = 0; |
|
014cc362aa91
Initialize thread_id to 0 in unthreaded build. Fixes #770247.
Martin v. Löwis <martin@v.loewis.de>
parents:
29643
diff
changeset
|
179 #endif |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
180 |
|
7970
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
181 tstate->dict = NULL; |
|
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
182 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
183 tstate->curexc_type = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
184 tstate->curexc_value = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
185 tstate->curexc_traceback = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
186 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
187 tstate->exc_type = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
188 tstate->exc_value = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
189 tstate->exc_traceback = NULL; |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
190 |
|
18326
e427afb5637f
Revise the interface to the profiling and tracing support for the
Fred Drake <fdrake@acm.org>
parents:
16139
diff
changeset
|
191 tstate->c_profilefunc = NULL; |
|
e427afb5637f
Revise the interface to the profiling and tracing support for the
Fred Drake <fdrake@acm.org>
parents:
16139
diff
changeset
|
192 tstate->c_tracefunc = NULL; |
|
e427afb5637f
Revise the interface to the profiling and tracing support for the
Fred Drake <fdrake@acm.org>
parents:
16139
diff
changeset
|
193 tstate->c_profileobj = NULL; |
|
e427afb5637f
Revise the interface to the profiling and tracing support for the
Fred Drake <fdrake@acm.org>
parents:
16139
diff
changeset
|
194 tstate->c_traceobj = NULL; |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
195 |
| 35661 | 196 #ifdef WITH_THREAD |
| 35117 | 197 _PyGILState_NoteThreadState(tstate); |
| 35661 | 198 #endif |
| 35117 | 199 |
| 11011 | 200 HEAD_LOCK(); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
201 tstate->next = interp->tstate_head; |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
202 interp->tstate_head = tstate; |
| 11011 | 203 HEAD_UNLOCK(); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
204 } |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
205 |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
206 return tstate; |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
207 } |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
208 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
209 |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
210 void |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13256
diff
changeset
|
211 PyThreadState_Clear(PyThreadState *tstate) |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
212 { |
|
6549
a8e3b2e9f5d2
The warning about thread still having a frame now only happens in
Guido van Rossum <guido@python.org>
parents:
6124
diff
changeset
|
213 if (Py_VerboseFlag && tstate->frame != NULL) |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
214 fprintf(stderr, |
|
6124
cc2c84769636
Added missing newline to warning msg
Guido van Rossum <guido@python.org>
parents:
5926
diff
changeset
|
215 "PyThreadState_Clear: warning: thread still has a frame\n"); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
216 |
| 37752 | 217 Py_CLEAR(tstate->frame); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
218 |
| 37752 | 219 Py_CLEAR(tstate->dict); |
| 220 Py_CLEAR(tstate->async_exc); | |
|
7970
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
221 |
| 37752 | 222 Py_CLEAR(tstate->curexc_type); |
| 223 Py_CLEAR(tstate->curexc_value); | |
| 224 Py_CLEAR(tstate->curexc_traceback); | |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
225 |
| 37752 | 226 Py_CLEAR(tstate->exc_type); |
| 227 Py_CLEAR(tstate->exc_value); | |
| 228 Py_CLEAR(tstate->exc_traceback); | |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
229 |
|
18326
e427afb5637f
Revise the interface to the profiling and tracing support for the
Fred Drake <fdrake@acm.org>
parents:
16139
diff
changeset
|
230 tstate->c_profilefunc = NULL; |
|
e427afb5637f
Revise the interface to the profiling and tracing support for the
Fred Drake <fdrake@acm.org>
parents:
16139
diff
changeset
|
231 tstate->c_tracefunc = NULL; |
| 37752 | 232 Py_CLEAR(tstate->c_profileobj); |
| 233 Py_CLEAR(tstate->c_traceobj); | |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
234 } |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
235 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
236 |
|
16139
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
237 /* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */ |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
238 static void |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
239 tstate_delete_common(PyThreadState *tstate) |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
240 { |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
241 PyInterpreterState *interp; |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
242 PyThreadState **p; |
|
44832
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
243 PyThreadState *prev_p = NULL; |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
244 if (tstate == NULL) |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
245 Py_FatalError("PyThreadState_Delete: NULL tstate"); |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
246 interp = tstate->interp; |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
247 if (interp == NULL) |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
248 Py_FatalError("PyThreadState_Delete: NULL interp"); |
| 11011 | 249 HEAD_LOCK(); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
250 for (p = &interp->tstate_head; ; p = &(*p)->next) { |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
251 if (*p == NULL) |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
252 Py_FatalError( |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
253 "PyThreadState_Delete: invalid tstate"); |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
254 if (*p == tstate) |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
255 break; |
|
48167
a8a8232cb541
Adds a sanity check to avoid a *very rare* infinite loop due to a corrupt tls
Gregory P. Smith <greg@mad-scientist.com>
parents:
44832
diff
changeset
|
256 /* Sanity check. These states should never happen but if |
|
a8a8232cb541
Adds a sanity check to avoid a *very rare* infinite loop due to a corrupt tls
Gregory P. Smith <greg@mad-scientist.com>
parents:
44832
diff
changeset
|
257 * they do we must abort. Otherwise we'll end up spinning in |
|
a8a8232cb541
Adds a sanity check to avoid a *very rare* infinite loop due to a corrupt tls
Gregory P. Smith <greg@mad-scientist.com>
parents:
44832
diff
changeset
|
258 * in a tight loop with the lock held. A similar check is done |
|
a8a8232cb541
Adds a sanity check to avoid a *very rare* infinite loop due to a corrupt tls
Gregory P. Smith <greg@mad-scientist.com>
parents:
44832
diff
changeset
|
259 * in thread.c find_key(). */ |
|
44832
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
260 if (*p == prev_p) |
|
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
261 Py_FatalError( |
|
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
262 "PyThreadState_Delete: small circular list(!)" |
|
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
263 " and tstate not found."); |
|
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
264 prev_p = *p; |
|
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
265 if ((*p)->next == interp->tstate_head) |
|
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
266 Py_FatalError( |
|
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
267 "PyThreadState_Delete: circular list(!) and" |
|
eb2eafda29b7
Provide a sanity check during PyThreadState_DeleteCurrent() and
Gregory P. Smith <greg@mad-scientist.com>
parents:
41128
diff
changeset
|
268 " tstate not found."); |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
269 } |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
270 *p = tstate->next; |
| 11011 | 271 HEAD_UNLOCK(); |
|
33713
517e4ec0df89
PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly.
Tim Peters <tim.peters@gmail.com>
parents:
33711
diff
changeset
|
272 free(tstate); |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
273 } |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
274 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
275 |
|
16139
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
276 void |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
277 PyThreadState_Delete(PyThreadState *tstate) |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
278 { |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
279 if (tstate == _PyThreadState_Current) |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
280 Py_FatalError("PyThreadState_Delete: tstate is still current"); |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
281 tstate_delete_common(tstate); |
|
36683
da2a1049215d
Patch 1413181, by Gabriel Becedillas.
Tim Peters <tim.peters@gmail.com>
parents:
35661
diff
changeset
|
282 #ifdef WITH_THREAD |
|
da2a1049215d
Patch 1413181, by Gabriel Becedillas.
Tim Peters <tim.peters@gmail.com>
parents:
35661
diff
changeset
|
283 if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate) |
|
da2a1049215d
Patch 1413181, by Gabriel Becedillas.
Tim Peters <tim.peters@gmail.com>
parents:
35661
diff
changeset
|
284 PyThread_delete_key_value(autoTLSkey); |
|
da2a1049215d
Patch 1413181, by Gabriel Becedillas.
Tim Peters <tim.peters@gmail.com>
parents:
35661
diff
changeset
|
285 #endif /* WITH_THREAD */ |
|
16139
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
286 } |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
287 |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
288 |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
289 #ifdef WITH_THREAD |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
290 void |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
291 PyThreadState_DeleteCurrent() |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
292 { |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
293 PyThreadState *tstate = _PyThreadState_Current; |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
294 if (tstate == NULL) |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
295 Py_FatalError( |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
296 "PyThreadState_DeleteCurrent: no current tstate"); |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
297 _PyThreadState_Current = NULL; |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
298 tstate_delete_common(tstate); |
| 35117 | 299 if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate) |
| 300 PyThread_delete_key_value(autoTLSkey); | |
|
16139
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
301 PyEval_ReleaseLock(); |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
302 } |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
303 #endif /* WITH_THREAD */ |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
304 |
|
d96ce9708c00
Add a new API, PyThreadState_DeleteCurrent() that combines
Guido van Rossum <guido@python.org>
parents:
14378
diff
changeset
|
305 |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
306 PyThreadState * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13256
diff
changeset
|
307 PyThreadState_Get(void) |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
308 { |
|
9667
914f83e7fa0a
Make current_tstate a global, _PyThreadState_Current. This is to
Guido van Rossum <guido@python.org>
parents:
7970
diff
changeset
|
309 if (_PyThreadState_Current == NULL) |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
310 Py_FatalError("PyThreadState_Get: no current thread"); |
|
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
311 |
|
9667
914f83e7fa0a
Make current_tstate a global, _PyThreadState_Current. This is to
Guido van Rossum <guido@python.org>
parents:
7970
diff
changeset
|
312 return _PyThreadState_Current; |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
313 } |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
314 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
315 |
|
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
316 PyThreadState * |
|
37606
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
317 PyThreadState_Swap(PyThreadState *newts) |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
318 { |
|
37606
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
319 PyThreadState *oldts = _PyThreadState_Current; |
|
5926
8d2194e22e67
The last of the mass checkins for separate (sub)interpreters.
Guido van Rossum <guido@python.org>
parents:
5849
diff
changeset
|
320 |
|
37606
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
321 _PyThreadState_Current = newts; |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
322 /* It should not be possible for more than one thread state |
|
33698
090ffcb83f0a
Trim trailing whitespace.
Tim Peters <tim.peters@gmail.com>
parents:
32301
diff
changeset
|
323 to be used for a thread. Check this the best we can in debug |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
324 builds. |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
325 */ |
|
28914
33475661823d
Patch #729300: Disable error message if Python is not built for threads.
Martin v. Löwis <martin@v.loewis.de>
parents:
28694
diff
changeset
|
326 #if defined(Py_DEBUG) && defined(WITH_THREAD) |
|
37606
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
327 if (newts) { |
|
39830
0bac40e4d0c6
Forward-port of rev. 51857:
Georg Brandl <georg@python.org>
parents:
39431
diff
changeset
|
328 /* This can be called from PyEval_RestoreThread(). Similar |
|
0bac40e4d0c6
Forward-port of rev. 51857:
Georg Brandl <georg@python.org>
parents:
39431
diff
changeset
|
329 to it, we need to ensure errno doesn't change. |
|
0bac40e4d0c6
Forward-port of rev. 51857:
Georg Brandl <georg@python.org>
parents:
39431
diff
changeset
|
330 */ |
|
0bac40e4d0c6
Forward-port of rev. 51857:
Georg Brandl <georg@python.org>
parents:
39431
diff
changeset
|
331 int err = errno; |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
332 PyThreadState *check = PyGILState_GetThisThreadState(); |
|
37606
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
333 if (check && check->interp == newts->interp && check != newts) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
334 Py_FatalError("Invalid thread state for this thread"); |
|
39830
0bac40e4d0c6
Forward-port of rev. 51857:
Georg Brandl <georg@python.org>
parents:
39431
diff
changeset
|
335 errno = err; |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
336 } |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
337 #endif |
|
37606
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
338 return oldts; |
|
5405
b7871ca930ad
Massive changes for separate thread state management.
Guido van Rossum <guido@python.org>
parents:
diff
changeset
|
339 } |
|
7970
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
340 |
|
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
341 /* An extension mechanism to store arbitrary additional per-thread state. |
|
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
342 PyThreadState_GetDict() returns a dictionary that can be used to hold such |
|
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
343 state; the caller should pick a unique key and store its state there. If |
|
28616
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
344 PyThreadState_GetDict() returns NULL, an exception has *not* been raised |
|
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
345 and the caller should assume no per-thread state is available. */ |
|
7970
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
346 |
|
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
347 PyObject * |
|
13658
f79434ee41fa
Mass ANSIfication of function definitions. Doesn't cover all 'extern'
Thomas Wouters <thomas@python.org>
parents:
13256
diff
changeset
|
348 PyThreadState_GetDict(void) |
|
7970
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
349 { |
|
9667
914f83e7fa0a
Make current_tstate a global, _PyThreadState_Current. This is to
Guido van Rossum <guido@python.org>
parents:
7970
diff
changeset
|
350 if (_PyThreadState_Current == NULL) |
|
28616
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
351 return NULL; |
|
7970
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
352 |
|
28616
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
353 if (_PyThreadState_Current->dict == NULL) { |
|
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
354 PyObject *d; |
|
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
355 _PyThreadState_Current->dict = d = PyDict_New(); |
|
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
356 if (d == NULL) |
|
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
357 PyErr_Clear(); |
|
4f0b7acffc7d
- pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences()
Guido van Rossum <guido@python.org>
parents:
28325
diff
changeset
|
358 } |
|
9667
914f83e7fa0a
Make current_tstate a global, _PyThreadState_Current. This is to
Guido van Rossum <guido@python.org>
parents:
7970
diff
changeset
|
359 return _PyThreadState_Current->dict; |
|
7970
4ceee1ef99b0
/* An extension mechanism to store arbitrary additional per-thread state.
Guido van Rossum <guido@python.org>
parents:
6549
diff
changeset
|
360 } |
|
18733
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
361 |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
362 |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
363 /* Asynchronously raise an exception in a thread. |
|
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
364 Requested by Just van Rossum and Alex Martelli. |
| 34568 | 365 To prevent naive misuse, you must write your own extension |
|
39431
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
366 to call this, or use ctypes. Must be called with the GIL held. |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
367 Returns the number of tstates modified (normally 1, but 0 if `id` didn't |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
368 match any known thread id). Can be called with exc=NULL to clear an |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
369 existing async exception. This raises no exceptions. */ |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
370 |
|
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
371 int |
|
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
372 PyThreadState_SetAsyncExc(long id, PyObject *exc) { |
|
31797
846b3ee7e106
Changed random calls to PyThreadState_Get() to use the macro
Nicholas Bastin <nick.bastin@gmail.com>
parents:
29842
diff
changeset
|
373 PyThreadState *tstate = PyThreadState_GET(); |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
374 PyInterpreterState *interp = tstate->interp; |
|
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
375 PyThreadState *p; |
|
39431
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
376 |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
377 /* Although the GIL is held, a few C API functions can be called |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
378 * without the GIL held, and in particular some that create and |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
379 * destroy thread and interpreter states. Those can mutate the |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
380 * list of thread states we're traversing, so to prevent that we lock |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
381 * head_mutex for the duration. |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
382 */ |
| 34568 | 383 HEAD_LOCK(); |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
384 for (p = interp->tstate_head; p != NULL; p = p->next) { |
|
39431
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
385 if (p->thread_id == id) { |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
386 /* Tricky: we need to decref the current value |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
387 * (if any) in p->async_exc, but that can in turn |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
388 * allow arbitrary Python code to run, including |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
389 * perhaps calls to this function. To prevent |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
390 * deadlock, we need to release head_mutex before |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
391 * the decref. |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
392 */ |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
393 PyObject *old_exc = p->async_exc; |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
394 Py_XINCREF(exc); |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
395 p->async_exc = exc; |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
396 HEAD_UNLOCK(); |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
397 Py_XDECREF(old_exc); |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
398 return 1; |
|
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
399 } |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
400 } |
| 34568 | 401 HEAD_UNLOCK(); |
|
39431
de9e1a5dca93
Followup to bug #1069160.
Tim Peters <tim.peters@gmail.com>
parents:
39129
diff
changeset
|
402 return 0; |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
403 } |
|
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
404 |
|
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
405 |
|
18733
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
406 /* Routines for advanced debuggers, requested by David Beazley. |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
407 Don't use unless you know what you are doing! */ |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
408 |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
409 PyInterpreterState * |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
410 PyInterpreterState_Head(void) |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
411 { |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
412 return interp_head; |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
413 } |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
414 |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
415 PyInterpreterState * |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
416 PyInterpreterState_Next(PyInterpreterState *interp) { |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
417 return interp->next; |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
418 } |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
419 |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
420 PyThreadState * |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
421 PyInterpreterState_ThreadHead(PyInterpreterState *interp) { |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
422 return interp->tstate_head; |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
423 } |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
424 |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
425 PyThreadState * |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
426 PyThreadState_Next(PyThreadState *tstate) { |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
427 return tstate->next; |
|
b0329649b8cf
Add a low-level API to access interpreters, for David Beazley.
Guido van Rossum <guido@python.org>
parents:
18689
diff
changeset
|
428 } |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
429 |
|
39118
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
430 /* The implementation of sys._current_frames(). This is intended to be |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
431 called with the GIL held, as it will be when called via |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
432 sys._current_frames(). It's possible it would work fine even without |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
433 the GIL held, but haven't thought enough about that. |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
434 */ |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
435 PyObject * |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
436 _PyThread_CurrentFrames(void) |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
437 { |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
438 PyObject *result; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
439 PyInterpreterState *i; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
440 |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
441 result = PyDict_New(); |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
442 if (result == NULL) |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
443 return NULL; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
444 |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
445 /* for i in all interpreters: |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
446 * for t in all of i's thread states: |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
447 * if t's frame isn't NULL, map t's id to its frame |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
448 * Because these lists can mutute even when the GIL is held, we |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
449 * need to grab head_mutex for the duration. |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
450 */ |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
451 HEAD_LOCK(); |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
452 for (i = interp_head; i != NULL; i = i->next) { |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
453 PyThreadState *t; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
454 for (t = i->tstate_head; t != NULL; t = t->next) { |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
455 PyObject *id; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
456 int stat; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
457 struct _frame *frame = t->frame; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
458 if (frame == NULL) |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
459 continue; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
460 id = PyInt_FromLong(t->thread_id); |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
461 if (id == NULL) |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
462 goto Fail; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
463 stat = PyDict_SetItem(result, id, (PyObject *)frame); |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
464 Py_DECREF(id); |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
465 if (stat < 0) |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
466 goto Fail; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
467 } |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
468 } |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
469 HEAD_UNLOCK(); |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
470 return result; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
471 |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
472 Fail: |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
473 HEAD_UNLOCK(); |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
474 Py_DECREF(result); |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
475 return NULL; |
|
85b23965ec4c
SF bug 1524317: configure --without-threads fails to build
Tim Peters <tim.peters@gmail.com>
parents:
39056
diff
changeset
|
476 } |
|
29643
fa97293533a9
Add PyThreadState_SetAsyncExc(long, PyObject *).
Guido van Rossum <guido@python.org>
parents:
28914
diff
changeset
|
477 |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
478 /* Python "auto thread state" API. */ |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
479 #ifdef WITH_THREAD |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
480 |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
481 /* Keep this as a static, as it is not reliable! It can only |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
482 ever be compared to the state for the *current* thread. |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
483 * If not equal, then it doesn't matter that the actual |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
484 value may change immediately after comparison, as it can't |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
485 possibly change to the current thread's state. |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
486 * If equal, then the current thread holds the lock, so the value can't |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
487 change until we yield the lock. |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
488 */ |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
489 static int |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
490 PyThreadState_IsCurrent(PyThreadState *tstate) |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
491 { |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
492 /* Must be the tstate for this thread */ |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
493 assert(PyGILState_GetThisThreadState()==tstate); |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
494 /* On Windows at least, simple reads and writes to 32 bit values |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
495 are atomic. |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
496 */ |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
497 return tstate == _PyThreadState_Current; |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
498 } |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
499 |
|
33698
090ffcb83f0a
Trim trailing whitespace.
Tim Peters <tim.peters@gmail.com>
parents:
32301
diff
changeset
|
500 /* Internal initialization/finalization functions called by |
|
090ffcb83f0a
Trim trailing whitespace.
Tim Peters <tim.peters@gmail.com>
parents:
32301
diff
changeset
|
501 Py_Initialize/Py_Finalize |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
502 */ |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
503 void |
|
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
504 _PyGILState_Init(PyInterpreterState *i, PyThreadState *t) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
505 { |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
506 assert(i && t); /* must init with valid states */ |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
507 autoTLSkey = PyThread_create_key(); |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
508 autoInterpreterState = i; |
|
33706
4981ba54f43d
_PyGILState_Init(), PyGILState_Ensure(): Since PyThread_set_key_value()
Tim Peters <tim.peters@gmail.com>
parents:
33699
diff
changeset
|
509 assert(PyThread_get_key_value(autoTLSkey) == NULL); |
| 35117 | 510 assert(t->gilstate_counter == 0); |
| 511 | |
| 512 _PyGILState_NoteThreadState(t); | |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
513 } |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
514 |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
515 void |
|
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
516 _PyGILState_Fini(void) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
517 { |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
518 PyThread_delete_key(autoTLSkey); |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
519 autoTLSkey = 0; |
|
39875
cab056903b3d
Remove extra semi-colons reported by Johnny Lee on python-dev. Backport if anyone cares.
Neal Norwitz <nnorwitz@gmail.com>
parents:
39830
diff
changeset
|
520 autoInterpreterState = NULL; |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
521 } |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
522 |
| 35117 | 523 /* When a thread state is created for a thread by some mechanism other than |
| 524 PyGILState_Ensure, it's important that the GILState machinery knows about | |
| 525 it so it doesn't try to create another thread state for the thread (this is | |
| 526 a better fix for SF bug #1010677 than the first one attempted). | |
| 527 */ | |
|
39830
0bac40e4d0c6
Forward-port of rev. 51857:
Georg Brandl <georg@python.org>
parents:
39431
diff
changeset
|
528 static void |
| 35117 | 529 _PyGILState_NoteThreadState(PyThreadState* tstate) |
| 530 { | |
| 531 /* If autoTLSkey is 0, this must be the very first threadstate created | |
| 532 in Py_Initialize(). Don't do anything for now (we'll be back here | |
| 533 when _PyGILState_Init is called). */ | |
|
39056
b6fd499e4343
After approval from Anthony, merge the tim-current_frames
Tim Peters <tim.peters@gmail.com>
parents:
37752
diff
changeset
|
534 if (!autoTLSkey) |
| 35117 | 535 return; |
|
39056
b6fd499e4343
After approval from Anthony, merge the tim-current_frames
Tim Peters <tim.peters@gmail.com>
parents:
37752
diff
changeset
|
536 |
| 35117 | 537 /* Stick the thread state for this thread in thread local storage. |
| 538 | |
| 539 The only situation where you can legitimately have more than one | |
| 540 thread state for an OS level thread is when there are multiple | |
| 541 interpreters, when: | |
|
39056
b6fd499e4343
After approval from Anthony, merge the tim-current_frames
Tim Peters <tim.peters@gmail.com>
parents:
37752
diff
changeset
|
542 |
| 35117 | 543 a) You shouldn't really be using the PyGILState_ APIs anyway, |
| 544 and: | |
| 545 | |
| 546 b) The slightly odd way PyThread_set_key_value works (see | |
| 547 comments by its implementation) means that the first thread | |
| 548 state created for that given OS level thread will "win", | |
| 549 which seems reasonable behaviour. | |
| 550 */ | |
| 551 if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0) | |
| 552 Py_FatalError("Couldn't create autoTLSkey mapping"); | |
| 553 | |
| 554 /* PyGILState_Release must not try to delete this thread state. */ | |
| 555 tstate->gilstate_counter = 1; | |
| 556 } | |
| 557 | |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
558 /* The public functions */ |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
559 PyThreadState * |
|
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
560 PyGILState_GetThisThreadState(void) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
561 { |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
562 if (autoInterpreterState == NULL || autoTLSkey == 0) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
563 return NULL; |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
564 return (PyThreadState *)PyThread_get_key_value(autoTLSkey); |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
565 } |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
566 |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
567 PyGILState_STATE |
|
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
568 PyGILState_Ensure(void) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
569 { |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
570 int current; |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
571 PyThreadState *tcur; |
|
33698
090ffcb83f0a
Trim trailing whitespace.
Tim Peters <tim.peters@gmail.com>
parents:
32301
diff
changeset
|
572 /* Note that we do not auto-init Python here - apart from |
|
090ffcb83f0a
Trim trailing whitespace.
Tim Peters <tim.peters@gmail.com>
parents:
32301
diff
changeset
|
573 potential races with 2 threads auto-initializing, pep-311 |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
574 spells out other issues. Embedders are expected to have |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
575 called Py_Initialize() and usually PyEval_InitThreads(). |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
576 */ |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
577 assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */ |
|
37606
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
578 tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey); |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
579 if (tcur == NULL) { |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
580 /* Create a new thread state for this thread */ |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
581 tcur = PyThreadState_New(autoInterpreterState); |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
582 if (tcur == NULL) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
583 Py_FatalError("Couldn't create thread-state for new thread"); |
| 35117 | 584 /* This is our thread state! We'll need to delete it in the |
| 585 matching call to PyGILState_Release(). */ | |
| 586 tcur->gilstate_counter = 0; | |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
587 current = 0; /* new thread state is never current */ |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
588 } |
|
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
589 else |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
590 current = PyThreadState_IsCurrent(tcur); |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
591 if (current == 0) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
592 PyEval_RestoreThread(tcur); |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
593 /* Update our counter in the thread-state - no need for locks: |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
594 - tcur will remain valid as we hold the GIL. |
|
33698
090ffcb83f0a
Trim trailing whitespace.
Tim Peters <tim.peters@gmail.com>
parents:
32301
diff
changeset
|
595 - the counter is safe as we are the only thread "allowed" |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
596 to modify this value |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
597 */ |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
598 ++tcur->gilstate_counter; |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
599 return current ? PyGILState_LOCKED : PyGILState_UNLOCKED; |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
600 } |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
601 |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
602 void |
|
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
603 PyGILState_Release(PyGILState_STATE oldstate) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
604 { |
|
37606
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
605 PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value( |
|
f448d0075691
more low-hanging fruit to make code compile under a C++ compiler. Not
Anthony Baxter <anthonybaxter@gmail.com>
parents:
36683
diff
changeset
|
606 autoTLSkey); |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
607 if (tcur == NULL) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
608 Py_FatalError("auto-releasing thread-state, " |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
609 "but no thread-state for this thread"); |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
610 /* We must hold the GIL and have our thread state current */ |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
611 /* XXX - remove the check - the assert should be fine, |
|
33698
090ffcb83f0a
Trim trailing whitespace.
Tim Peters <tim.peters@gmail.com>
parents:
32301
diff
changeset
|
612 but while this is very new (April 2003), the extra check |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
613 by release-only users can't hurt. |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
614 */ |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
615 if (! PyThreadState_IsCurrent(tcur)) |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
616 Py_FatalError("This thread state must be current when releasing"); |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
617 assert(PyThreadState_IsCurrent(tcur)); |
|
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
618 --tcur->gilstate_counter; |
|
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
619 assert(tcur->gilstate_counter >= 0); /* illegal counter value */ |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
620 |
|
33940
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
621 /* If we're going to destroy this thread-state, we must |
|
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
622 * clear it while the GIL is held, as destructors may run. |
|
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
623 */ |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
624 if (tcur->gilstate_counter == 0) { |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
625 /* can't have been locked when we created it */ |
|
33699
0c26db381673
Style guide & consistency changes. No semantic changes.
Tim Peters <tim.peters@gmail.com>
parents:
33698
diff
changeset
|
626 assert(oldstate == PyGILState_UNLOCKED); |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
627 PyThreadState_Clear(tcur); |
|
33940
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
628 /* Delete the thread-state. Note this releases the GIL too! |
|
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
629 * It's vital that the GIL be held here, to avoid shutdown |
|
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
630 * races; see bugs 225673 and 1061968 (that nasty bug has a |
|
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
631 * habit of coming back). |
|
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
632 */ |
|
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
633 PyThreadState_DeleteCurrent(); |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
634 } |
|
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
635 /* Release the lock if necessary */ |
|
33940
dfd07b7be407
SF bug 1061968: threads: segfault or Py_FatalError at exit
Tim Peters <tim.peters@gmail.com>
parents:
33714
diff
changeset
|
636 else if (oldstate == PyGILState_UNLOCKED) |
|
34928
9857daa22807
Backport my recent fix (rev. 2.40 of Python/pystate.c):
Michael W. Hudson <mwh@python.net>
parents:
34568
diff
changeset
|
637 PyEval_SaveThread(); |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
638 } |
|
37655
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
639 |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
640 #ifdef __cplusplus |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
641 } |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
642 #endif |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
643 |
|
28694
a4154dd5939a
New PyGILState_ API - implements pep 311, from patch 684256.
Mark Hammond <mhammond@skippinet.com.au>
parents:
28616
diff
changeset
|
644 #endif /* WITH_THREAD */ |
|
37655
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
645 |
|
2f3f2e32dfd9
spread the extern "C" { } magic pixie dust around. Python itself builds now
Anthony Baxter <anthonybaxter@gmail.com>
parents:
37606
diff
changeset
|
646 |
