cpython-lru_cache-weakref: Python/pystate.c annotate

annotate Python/pystate.c @ 45151:643c1397f954 legacy-trunk

#1750076: Debugger did not step on every iteration of a while statement. The mapping between bytecode offsets and source lines (lnotab) did not contain an entry for the beginning of the loop. Now it does, and the lnotab can be a bit larger: in particular, several statements on the same line generate several entries. However, this does not bother the settrace function, which will trigger only one 'line' event. The lnotab seems to be exactly the same as with python2.4.

author	Amaury Forgeot d'Arc <amauryfa@gmail.com>
date	Mon, 04 Feb 2008 21:45:05 +0000
parents	eb2eafda29b7
children	a8a8232cb541

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 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	26 #ifdef WITH_THREAD
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	27 #include "pythread.h"
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	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 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	30 #define HEAD_LOCK() PyThread_acquire_lock(head_mutex, WAIT_LOCK)
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	31 #define HEAD_UNLOCK() PyThread_release_lock(head_mutex)
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	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 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	37 /* The single PyInterpreterState used by this process'
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	38 GILState implementation
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	39 */
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	40 static PyInterpreterState *autoInterpreterState = NULL;
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	41 static int autoTLSkey = 0;
11011 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	42 #else
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	43 #define HEAD_INIT() /* Nothing */
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	44 #define HEAD_LOCK() /* Nothing */
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	45 #define HEAD_UNLOCK() /* Nothing */
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	46 #endif
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	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 85651eb3d9a9 Forward port bugfix: Michael W. Hudson <mwh@python.net> parents: 35117 diff changeset	53 #ifdef WITH_THREAD
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	54 static void _PyGILState_NoteThreadState(PyThreadState* tstate);
35661 85651eb3d9a9 Forward port bugfix: Michael W. Hudson <mwh@python.net> parents: 35117 diff changeset	55 #endif
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	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 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	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 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	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 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	106 HEAD_UNLOCK();
37752 7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	107 Py_CLEAR(interp->codec_search_path);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	108 Py_CLEAR(interp->codec_search_cache);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	109 Py_CLEAR(interp->codec_error_registry);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	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 7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	112 Py_CLEAR(interp->sysdict);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	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 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	120 PyThreadState *p;
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	121 /* No need to lock the mutex here because this should only happen
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	122 when the threads are all really dead (XXX famous last words). */
3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	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 85651eb3d9a9 Forward port bugfix: Michael W. Hudson <mwh@python.net> parents: 35117 diff changeset	196 #ifdef WITH_THREAD
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	197 _PyGILState_NoteThreadState(tstate);
35661 85651eb3d9a9 Forward port bugfix: Michael W. Hudson <mwh@python.net> parents: 35117 diff changeset	198 #endif
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	199
11011 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	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 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	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 7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	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 7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	219 Py_CLEAR(tstate->dict);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	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 7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	222 Py_CLEAR(tstate->curexc_type);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	223 Py_CLEAR(tstate->curexc_value);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	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 7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	226 Py_CLEAR(tstate->exc_type);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	227 Py_CLEAR(tstate->exc_value);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	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 7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	232 Py_CLEAR(tstate->c_profileobj);
7f72791f0aec Zap ZAP. Martin v. Löwis <martin@v.loewis.de> parents: 37655 diff changeset	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 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	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;
44832 eb2eafda29b7 Provide a sanity check during PyThreadState_DeleteCurrent() and Gregory P. Smith <greg@mad-scientist.com> parents: 41128 diff changeset	256 if (*p == prev_p)
eb2eafda29b7 Provide a sanity check during PyThreadState_DeleteCurrent() and Gregory P. Smith <greg@mad-scientist.com> parents: 41128 diff changeset	257 Py_FatalError(
eb2eafda29b7 Provide a sanity check during PyThreadState_DeleteCurrent() and Gregory P. Smith <greg@mad-scientist.com> parents: 41128 diff changeset	258 "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	259 " and tstate not found.");
eb2eafda29b7 Provide a sanity check during PyThreadState_DeleteCurrent() and Gregory P. Smith <greg@mad-scientist.com> parents: 41128 diff changeset	260 prev_p = *p;
eb2eafda29b7 Provide a sanity check during PyThreadState_DeleteCurrent() and Gregory P. Smith <greg@mad-scientist.com> parents: 41128 diff changeset	261 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	262 Py_FatalError(
eb2eafda29b7 Provide a sanity check during PyThreadState_DeleteCurrent() and Gregory P. Smith <greg@mad-scientist.com> parents: 41128 diff changeset	263 "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	264 " 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	265 }
8d2194e22e67 The last of the mass checkins for separate (sub)interpreters. Guido van Rossum <guido@python.org> parents: 5849 diff changeset	266 *p = tstate->next;
11011 3b3c7b8ade7f CRITICAL PATCH! Guido van Rossum <guido@python.org> parents: 9667 diff changeset	267 HEAD_UNLOCK();
33713 517e4ec0df89 PyInterpreterState_New(), PyThreadState_New(): use malloc/free directly. Tim Peters <tim.peters@gmail.com> parents: 33711 diff changeset	268 free(tstate);
5405 b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	269 }
b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	270
b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	271
16139 d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	272 void
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	273 PyThreadState_Delete(PyThreadState *tstate)
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	274 {
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	275 if (tstate == _PyThreadState_Current)
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	276 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	277 tstate_delete_common(tstate);
36683 da2a1049215d Patch 1413181, by Gabriel Becedillas. Tim Peters <tim.peters@gmail.com> parents: 35661 diff changeset	278 #ifdef WITH_THREAD
da2a1049215d Patch 1413181, by Gabriel Becedillas. Tim Peters <tim.peters@gmail.com> parents: 35661 diff changeset	279 if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate)
da2a1049215d Patch 1413181, by Gabriel Becedillas. Tim Peters <tim.peters@gmail.com> parents: 35661 diff changeset	280 PyThread_delete_key_value(autoTLSkey);
da2a1049215d Patch 1413181, by Gabriel Becedillas. Tim Peters <tim.peters@gmail.com> parents: 35661 diff changeset	281 #endif /* WITH_THREAD */
16139 d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	282 }
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	283
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	284
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	285 #ifdef WITH_THREAD
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	286 void
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	287 PyThreadState_DeleteCurrent()
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 PyThreadState *tstate = _PyThreadState_Current;
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	290 if (tstate == NULL)
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	291 Py_FatalError(
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	292 "PyThreadState_DeleteCurrent: no current tstate");
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	293 _PyThreadState_Current = NULL;
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	294 tstate_delete_common(tstate);
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	295 if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate)
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	296 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	297 PyEval_ReleaseLock();
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	298 }
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	299 #endif /* WITH_THREAD */
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	300
d96ce9708c00 Add a new API, PyThreadState_DeleteCurrent() that combines Guido van Rossum <guido@python.org> parents: 14378 diff changeset	301
5405 b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	302 PyThreadState *
13658 f79434ee41fa Mass ANSIfication of function definitions. Doesn't cover all 'extern' Thomas Wouters <thomas@python.org> parents: 13256 diff changeset	303 PyThreadState_Get(void)
5405 b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	304 {
9667 914f83e7fa0a Make current_tstate a global, _PyThreadState_Current. This is to Guido van Rossum <guido@python.org> parents: 7970 diff changeset	305 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	306 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	307
9667 914f83e7fa0a Make current_tstate a global, _PyThreadState_Current. This is to Guido van Rossum <guido@python.org> parents: 7970 diff changeset	308 return _PyThreadState_Current;
5405 b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	309 }
b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	310
b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	311
b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	312 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	313 PyThreadState_Swap(PyThreadState *newts)
5405 b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	314 {
37606 f448d0075691 more low-hanging fruit to make code compile under a C++ compiler. Not Anthony Baxter <anthonybaxter@gmail.com> parents: 36683 diff changeset	315 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	316
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_Current = newts;
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	318 /* 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	319 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	320 builds.
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	321 */
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	322 #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	323 if (newts) {
39830 0bac40e4d0c6 Forward-port of rev. 51857: Georg Brandl <georg@python.org> parents: 39431 diff changeset	324 /* This can be called from PyEval_RestoreThread(). Similar
0bac40e4d0c6 Forward-port of rev. 51857: Georg Brandl <georg@python.org> parents: 39431 diff changeset	325 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	326 */
0bac40e4d0c6 Forward-port of rev. 51857: Georg Brandl <georg@python.org> parents: 39431 diff changeset	327 int err = errno;
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	328 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	329 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	330 Py_FatalError("Invalid thread state for this thread");
39830 0bac40e4d0c6 Forward-port of rev. 51857: Georg Brandl <georg@python.org> parents: 39431 diff changeset	331 errno = err;
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	332 }
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	333 #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	334 return oldts;
5405 b7871ca930ad Massive changes for separate thread state management. Guido van Rossum <guido@python.org> parents: diff changeset	335 }
7970 4ceee1ef99b0 /* An extension mechanism to store arbitrary additional per-thread state. Guido van Rossum <guido@python.org> parents: 6549 diff changeset	336
4ceee1ef99b0 /* An extension mechanism to store arbitrary additional per-thread state. Guido van Rossum <guido@python.org> parents: 6549 diff changeset	337 /* 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	338 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	339 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	340 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	341 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	342
4ceee1ef99b0 /* An extension mechanism to store arbitrary additional per-thread state. Guido van Rossum <guido@python.org> parents: 6549 diff changeset	343 PyObject *
13658 f79434ee41fa Mass ANSIfication of function definitions. Doesn't cover all 'extern' Thomas Wouters <thomas@python.org> parents: 13256 diff changeset	344 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	345 {
9667 914f83e7fa0a Make current_tstate a global, _PyThreadState_Current. This is to Guido van Rossum <guido@python.org> parents: 7970 diff changeset	346 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	347 return NULL;
7970 4ceee1ef99b0 /* An extension mechanism to store arbitrary additional per-thread state. Guido van Rossum <guido@python.org> parents: 6549 diff changeset	348
28616 4f0b7acffc7d - pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences() Guido van Rossum <guido@python.org> parents: 28325 diff changeset	349 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	350 PyObject *d;
4f0b7acffc7d - pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences() Guido van Rossum <guido@python.org> parents: 28325 diff changeset	351 _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	352 if (d == NULL)
4f0b7acffc7d - pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences() Guido van Rossum <guido@python.org> parents: 28325 diff changeset	353 PyErr_Clear();
4f0b7acffc7d - pythunrun.c, Py_Finalize(): move the call to _Py_PrintReferences() Guido van Rossum <guido@python.org> parents: 28325 diff changeset	354 }
9667 914f83e7fa0a Make current_tstate a global, _PyThreadState_Current. This is to Guido van Rossum <guido@python.org> parents: 7970 diff changeset	355 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	356 }
18733 b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	357
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	358
29643 fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	359 /* Asynchronously raise an exception in a thread.
fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	360 Requested by Just van Rossum and Alex Martelli.
34568 ff3ca656c281 Backport 2.39: Guido van Rossum <guido@python.org> parents: 33940 diff changeset	361 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	362 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	363 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	364 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	365 existing async exception. This raises no exceptions. */
29643 fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	366
fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	367 int
fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	368 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	369 PyThreadState *tstate = PyThreadState_GET();
29643 fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	370 PyInterpreterState *interp = tstate->interp;
fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	371 PyThreadState *p;
39431 de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	372
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	373 /* 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	374 * 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	375 * destroy thread and interpreter states. Those can mutate the
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	376 * 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	377 * head_mutex for the duration.
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	378 */
34568 ff3ca656c281 Backport 2.39: Guido van Rossum <guido@python.org> parents: 33940 diff changeset	379 HEAD_LOCK();
29643 fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	380 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	381 if (p->thread_id == id) {
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	382 /* Tricky: we need to decref the current value
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	383 * (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	384 * allow arbitrary Python code to run, including
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	385 * perhaps calls to this function. To prevent
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	386 * deadlock, we need to release head_mutex before
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	387 * the decref.
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	388 */
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	389 PyObject *old_exc = p->async_exc;
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	390 Py_XINCREF(exc);
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	391 p->async_exc = exc;
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	392 HEAD_UNLOCK();
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	393 Py_XDECREF(old_exc);
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	394 return 1;
de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	395 }
29643 fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	396 }
34568 ff3ca656c281 Backport 2.39: Guido van Rossum <guido@python.org> parents: 33940 diff changeset	397 HEAD_UNLOCK();
39431 de9e1a5dca93 Followup to bug #1069160. Tim Peters <tim.peters@gmail.com> parents: 39129 diff changeset	398 return 0;
29643 fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	399 }
fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	400
fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	401
18733 b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	402 /* 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	403 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	404
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	405 PyInterpreterState *
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	406 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	407 {
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	408 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	409 }
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	410
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	411 PyInterpreterState *
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	412 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	413 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	414 }
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	415
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	416 PyThreadState *
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	417 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	418 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	419 }
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	420
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	421 PyThreadState *
b0329649b8cf Add a low-level API to access interpreters, for David Beazley. Guido van Rossum <guido@python.org> parents: 18689 diff changeset	422 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	423 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	424 }
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	425
39118 85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	426 /* 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	427 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	428 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	429 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	430 */
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	431 PyObject *
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	432 _PyThread_CurrentFrames(void)
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	433 {
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	434 PyObject *result;
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	435 PyInterpreterState *i;
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	436
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	437 result = PyDict_New();
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	438 if (result == NULL)
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	439 return NULL;
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 /* 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	442 * 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	443 * 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	444 * 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	445 * 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	446 */
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	447 HEAD_LOCK();
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	448 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	449 PyThreadState *t;
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	450 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	451 PyObject *id;
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	452 int stat;
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	453 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	454 if (frame == NULL)
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	455 continue;
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	456 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	457 if (id == NULL)
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	458 goto Fail;
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	459 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	460 Py_DECREF(id);
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	461 if (stat < 0)
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 }
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	464 }
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	465 HEAD_UNLOCK();
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	466 return result;
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 Fail:
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 Py_DECREF(result);
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	471 return NULL;
85b23965ec4c SF bug 1524317: configure --without-threads fails to build Tim Peters <tim.peters@gmail.com> parents: 39056 diff changeset	472 }
29643 fa97293533a9 Add PyThreadState_SetAsyncExc(long, PyObject ). Guido van Rossum <guido@python.org>* parents: 28914 diff changeset	473
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	474 /* 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	475 #ifdef WITH_THREAD
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	476
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	477 /* 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	478 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	479 * 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	480 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	481 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	482 * 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	483 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	484 */
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	485 static int
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	486 PyThreadState_IsCurrent(PyThreadState *tstate)
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	487 {
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	488 /* 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	489 assert(PyGILState_GetThisThreadState()==tstate);
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	490 /* 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	491 are atomic.
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	492 */
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	493 return tstate == _PyThreadState_Current;
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	494 }
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	495
33698 090ffcb83f0a Trim trailing whitespace. Tim Peters <tim.peters@gmail.com> parents: 32301 diff changeset	496 /* Internal initialization/finalization functions called by
090ffcb83f0a Trim trailing whitespace. Tim Peters <tim.peters@gmail.com> parents: 32301 diff changeset	497 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	498 */
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	499 void
0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	500 _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	501 {
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	502 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	503 autoTLSkey = PyThread_create_key();
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	504 autoInterpreterState = i;
33706 4981ba54f43d _PyGILState_Init(), PyGILState_Ensure(): Since PyThread_set_key_value() Tim Peters <tim.peters@gmail.com> parents: 33699 diff changeset	505 assert(PyThread_get_key_value(autoTLSkey) == NULL);
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	506 assert(t->gilstate_counter == 0);
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	507
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	508 _PyGILState_NoteThreadState(t);
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	509 }
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	510
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	511 void
0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	512 _PyGILState_Fini(void)
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 PyThread_delete_key(autoTLSkey);
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	515 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	516 autoInterpreterState = NULL;
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
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	519 /* When a thread state is created for a thread by some mechanism other than
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	520 PyGILState_Ensure, it's important that the GILState machinery knows about
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	521 it so it doesn't try to create another thread state for the thread (this is
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	522 a better fix for SF bug #1010677 than the first one attempted).
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	523 */
39830 0bac40e4d0c6 Forward-port of rev. 51857: Georg Brandl <georg@python.org> parents: 39431 diff changeset	524 static void
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	525 _PyGILState_NoteThreadState(PyThreadState* tstate)
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	526 {
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	527 /* If autoTLSkey is 0, this must be the very first threadstate created
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	528 in Py_Initialize(). Don't do anything for now (we'll be back here
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	529 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	530 if (!autoTLSkey)
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	531 return;
39056 b6fd499e4343 After approval from Anthony, merge the tim-current_frames Tim Peters <tim.peters@gmail.com> parents: 37752 diff changeset	532
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	533 /* Stick the thread state for this thread in thread local storage.
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	534
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	535 The only situation where you can legitimately have more than one
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	536 thread state for an OS level thread is when there are multiple
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	537 interpreters, when:
39056 b6fd499e4343 After approval from Anthony, merge the tim-current_frames Tim Peters <tim.peters@gmail.com> parents: 37752 diff changeset	538
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	539 a) You shouldn't really be using the PyGILState_ APIs anyway,
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	540 and:
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	541
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	542 b) The slightly odd way PyThread_set_key_value works (see
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	543 comments by its implementation) means that the first thread
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	544 state created for that given OS level thread will "win",
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	545 which seems reasonable behaviour.
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	546 */
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	547 if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0)
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	548 Py_FatalError("Couldn't create autoTLSkey mapping");
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	549
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	550 /* PyGILState_Release must not try to delete this thread state. */
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	551 tstate->gilstate_counter = 1;
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	552 }
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	553
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	554 /* The public functions */
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	555 PyThreadState *
0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	556 PyGILState_GetThisThreadState(void)
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	557 {
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	558 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	559 return NULL;
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	560 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	561 }
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	562
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	563 PyGILState_STATE
0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	564 PyGILState_Ensure(void)
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 int current;
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	567 PyThreadState *tcur;
33698 090ffcb83f0a Trim trailing whitespace. Tim Peters <tim.peters@gmail.com> parents: 32301 diff changeset	568 /* 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	569 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	570 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	571 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	572 */
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	573 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	574 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	575 if (tcur == NULL) {
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	576 /* 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	577 tcur = PyThreadState_New(autoInterpreterState);
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	578 if (tcur == NULL)
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	579 Py_FatalError("Couldn't create thread-state for new thread");
35117 7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	580 /* This is our thread state! We'll need to delete it in the
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	581 matching call to PyGILState_Release(). */
7ea2be2c0e1d Fix bug: Michael W. Hudson <mwh@python.net> parents: 35095 diff changeset	582 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	583 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	584 }
0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	585 else
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	586 current = PyThreadState_IsCurrent(tcur);
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	587 if (current == 0)
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	588 PyEval_RestoreThread(tcur);
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	589 /* 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	590 - tcur will remain valid as we hold the GIL.
33698 090ffcb83f0a Trim trailing whitespace. Tim Peters <tim.peters@gmail.com> parents: 32301 diff changeset	591 - 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	592 to modify this value
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	593 */
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	594 ++tcur->gilstate_counter;
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	595 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	596 }
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 void
0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	599 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	600 {
37606 f448d0075691 more low-hanging fruit to make code compile under a C++ compiler. Not Anthony Baxter <anthonybaxter@gmail.com> parents: 36683 diff changeset	601 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	602 autoTLSkey);
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	603 if (tcur == NULL)
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	604 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	605 "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	606 /* 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	607 /* XXX - remove the check - the assert should be fine,
33698 090ffcb83f0a Trim trailing whitespace. Tim Peters <tim.peters@gmail.com> parents: 32301 diff changeset	608 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	609 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	610 */
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	611 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	612 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	613 assert(PyThreadState_IsCurrent(tcur));
0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	614 --tcur->gilstate_counter;
0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	615 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	616
33940 dfd07b7be407 SF bug 1061968: threads: segfault or Py_FatalError at exit Tim Peters <tim.peters@gmail.com> parents: 33714 diff changeset	617 /* 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	618 * 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	619 */
33699 0c26db381673 Style guide & consistency changes. No semantic changes. Tim Peters <tim.peters@gmail.com> parents: 33698 diff changeset	620 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	621 /* 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	622 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	623 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	624 /* 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	625 * 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	626 * 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	627 * 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	628 */
dfd07b7be407 SF bug 1061968: threads: segfault or Py_FatalError at exit Tim Peters <tim.peters@gmail.com> parents: 33714 diff changeset	629 PyThreadState_DeleteCurrent();
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	630 }
a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	631 /* 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	632 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	633 PyEval_SaveThread();
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	634 }
37655 2f3f2e32dfd9 spread the extern "C" { } magic pixie dust around. Python itself builds now Anthony Baxter <anthonybaxter@gmail.com> parents: 37606 diff changeset	635
2f3f2e32dfd9 spread the extern "C" { } magic pixie dust around. Python itself builds now Anthony Baxter <anthonybaxter@gmail.com> parents: 37606 diff changeset	636 #ifdef __cplusplus
2f3f2e32dfd9 spread the extern "C" { } magic pixie dust around. Python itself builds now Anthony Baxter <anthonybaxter@gmail.com> parents: 37606 diff changeset	637 }
2f3f2e32dfd9 spread the extern "C" { } magic pixie dust around. Python itself builds now Anthony Baxter <anthonybaxter@gmail.com> parents: 37606 diff changeset	638 #endif
2f3f2e32dfd9 spread the extern "C" { } magic pixie dust around. Python itself builds now Anthony Baxter <anthonybaxter@gmail.com> parents: 37606 diff changeset	639
28694 a4154dd5939a New PyGILState_ API - implements pep 311, from patch 684256. Mark Hammond <mhammond@skippinet.com.au> parents: 28616 diff changeset	640 #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	641
2f3f2e32dfd9 spread the extern "C" { } magic pixie dust around. Python itself builds now Anthony Baxter <anthonybaxter@gmail.com> parents: 37606 diff changeset	642

Mercurial > cpython-lru_cache-weakref

annotate Python/pystate.c @ 45151:643c1397f954 legacy-trunk