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

annotate Python/pystate.c @ 41636:be1e708d5d3d 2.5

Fix NonRecursiveMutex on x64. The signature of the faux-InterlockedCompareExchange function was wrong: It works with LONG and not PVOID objects, and it needs to have the target marked as volatile. Further, it is not needed at all for x64 targets, since that platform always has the real McCoy.

author	Kristján Valur Jónsson <kristjan@ccpgames.com>
date	Mon, 07 May 2007 18:28:12 +0000
parents	66f265ac4ec4
children	eefe4450f773 eb2eafda29b7

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

Mercurial > cpython-lru_cache-weakref

annotate Python/pystate.c @ 41636:be1e708d5d3d 2.5