/* Thread and interpreter state structures and their interfaces */ #include "Python.h" #include "pycore_abstract.h" // _PyIndex_Check() #include "pycore_ceval.h" #include "pycore_code.h" // stats #include "pycore_critical_section.h" // _PyCriticalSection_Resume() #include "pycore_dtoa.h" // _dtoa_state_INIT() #include "pycore_emscripten_trampoline.h" // _Py_EmscriptenTrampoline_Init() #include "pycore_frame.h" #include "pycore_freelist.h" // _PyObject_ClearFreeLists() #include "pycore_initconfig.h" // _PyStatus_OK() #include "pycore_object.h" // _PyType_InitCache() #include "pycore_parking_lot.h" // _PyParkingLot_AfterFork() #include "pycore_pyerrors.h" // _PyErr_Clear() #include "pycore_pylifecycle.h" // _PyAST_Fini() #include "pycore_pymem.h" // _PyMem_SetDefaultAllocator() #include "pycore_pystate.h" #include "pycore_runtime_init.h" // _PyRuntimeState_INIT #include "pycore_sysmodule.h" // _PySys_Audit() #include "pycore_obmalloc.h" // _PyMem_obmalloc_state_on_heap() #include "pycore_uniqueid.h" // _PyObject_FinalizePerThreadRefcounts() /* -------------------------------------------------------------------------- CAUTION Always use PyMem_RawMalloc() and PyMem_RawFree() directly in this file. A number of these functions are advertised as safe to call when the GIL isn't held, and in a debug build Python redirects (e.g.) PyMem_NEW (etc) to Python's debugging obmalloc functions. Those aren't thread-safe (they rely on the GIL to avoid the expense of doing their own locking). -------------------------------------------------------------------------- */ #ifdef HAVE_DLOPEN # ifdef HAVE_DLFCN_H # include <dlfcn.h> # endif # if !HAVE_DECL_RTLD_LAZY #define RTLD_LAZY … # endif #endif /****************************************/ /* helpers for the current thread state */ /****************************************/ // API for the current thread state is further down. /* "current" means one of: - bound to the current OS thread - holds the GIL */ //------------------------------------------------- // a highly efficient lookup for the current thread //------------------------------------------------- /* The stored thread state is set by PyThreadState_Swap(). For each of these functions, the GIL must be held by the current thread. */ #ifdef HAVE_THREAD_LOCAL _Py_thread_local PyThreadState *_Py_tss_tstate = …; #endif static inline PyThreadState * current_fast_get(void) { … } static inline void current_fast_set(_PyRuntimeState *Py_UNUSED(runtime), PyThreadState *tstate) { … } static inline void current_fast_clear(_PyRuntimeState *Py_UNUSED(runtime)) { … } #define tstate_verify_not_active(tstate) … PyThreadState * _PyThreadState_GetCurrent(void) { … } //------------------------------------------------ // the thread state bound to the current OS thread //------------------------------------------------ static inline int tstate_tss_initialized(Py_tss_t *key) { … } static inline int tstate_tss_init(Py_tss_t *key) { … } static inline void tstate_tss_fini(Py_tss_t *key) { … } static inline PyThreadState * tstate_tss_get(Py_tss_t *key) { … } static inline int tstate_tss_set(Py_tss_t *key, PyThreadState *tstate) { … } static inline int tstate_tss_clear(Py_tss_t *key) { … } #ifdef HAVE_FORK /* Reset the TSS key - called by PyOS_AfterFork_Child(). * This should not be necessary, but some - buggy - pthread implementations * don't reset TSS upon fork(), see issue #10517. */ static PyStatus tstate_tss_reinit(Py_tss_t *key) { … } #endif /* The stored thread state is set by bind_tstate() (AKA PyThreadState_Bind(). The GIL does no need to be held for these. */ #define gilstate_tss_initialized(runtime) … #define gilstate_tss_init(runtime) … #define gilstate_tss_fini(runtime) … #define gilstate_tss_get(runtime) … #define _gilstate_tss_set(runtime, tstate) … #define _gilstate_tss_clear(runtime) … #define gilstate_tss_reinit(runtime) … static inline void gilstate_tss_set(_PyRuntimeState *runtime, PyThreadState *tstate) { … } static inline void gilstate_tss_clear(_PyRuntimeState *runtime) { … } #ifndef NDEBUG static inline int tstate_is_alive(PyThreadState *tstate); static inline int tstate_is_bound(PyThreadState *tstate) { return tstate->_status.bound && !tstate->_status.unbound; } #endif // !NDEBUG static void bind_gilstate_tstate(PyThreadState *); static void unbind_gilstate_tstate(PyThreadState *); static void tstate_mimalloc_bind(PyThreadState *); static void bind_tstate(PyThreadState *tstate) { … } static void unbind_tstate(PyThreadState *tstate) { … } /* Stick the thread state for this thread in thread specific storage. When a thread state is created for a thread by some mechanism other than PyGILState_Ensure(), it's important that the GILState machinery knows about it so it doesn't try to create another thread state for the thread. (This is a better fix for SF bug #1010677 than the first one attempted.) The only situation where you can legitimately have more than one thread state for an OS level thread is when there are multiple interpreters. Before 3.12, the PyGILState_*() APIs didn't work with multiple interpreters (see bpo-10915 and bpo-15751), so this function used to set TSS only once. Thus, the first thread state created for that given OS level thread would "win", which seemed reasonable behaviour. */ static void bind_gilstate_tstate(PyThreadState *tstate) { … } static void unbind_gilstate_tstate(PyThreadState *tstate) { … } //---------------------------------------------- // the thread state that currently holds the GIL //---------------------------------------------- /* This is not exported, as it is not reliable! It can only ever be compared to the state for the *current* thread. * If not equal, then it doesn't matter that the actual value may change immediately after comparison, as it can't possibly change to the current thread's state. * If equal, then the current thread holds the lock, so the value can't change until we yield the lock. */ static int holds_gil(PyThreadState *tstate) { … } /****************************/ /* the global runtime state */ /****************************/ //---------- // lifecycle //---------- /* Suppress deprecation warning for PyBytesObject.ob_shash */ _Py_COMP_DIAG_PUSH _Py_COMP_DIAG_IGNORE_DEPR_DECLS /* We use "initial" if the runtime gets re-used (e.g. Py_Finalize() followed by Py_Initialize(). Note that we initialize "initial" relative to _PyRuntime, to ensure pre-initialized pointers point to the active runtime state (and not "initial"). */ static const _PyRuntimeState initial = …; _Py_COMP_DIAG_POP #define LOCKS_INIT(runtime) … static void init_runtime(_PyRuntimeState *runtime, void *open_code_hook, void *open_code_userdata, _Py_AuditHookEntry *audit_hook_head, Py_ssize_t unicode_next_index) { … } PyStatus _PyRuntimeState_Init(_PyRuntimeState *runtime) { … } void _PyRuntimeState_Fini(_PyRuntimeState *runtime) { … } #ifdef HAVE_FORK /* This function is called from PyOS_AfterFork_Child to ensure that newly created child processes do not share locks with the parent. */ PyStatus _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime) { … } #endif /*************************************/ /* the per-interpreter runtime state */ /*************************************/ //---------- // lifecycle //---------- /* Calling this indicates that the runtime is ready to create interpreters. */ PyStatus _PyInterpreterState_Enable(_PyRuntimeState *runtime) { … } static PyInterpreterState * alloc_interpreter(void) { … } static void free_interpreter(PyInterpreterState *interp) { … } #ifndef NDEBUG static inline int check_interpreter_whence(long); #endif /* Get the interpreter state to a minimal consistent state. Further init happens in pylifecycle.c before it can be used. All fields not initialized here are expected to be zeroed out, e.g. by PyMem_RawCalloc() or memset(), or otherwise pre-initialized. The runtime state is not manipulated. Instead it is assumed that the interpreter is getting added to the runtime. Note that the main interpreter was statically initialized as part of the runtime and most state is already set properly. That leaves a small number of fields to initialize dynamically, as well as some that are initialized lazily. For subinterpreters we memcpy() the main interpreter in PyInterpreterState_New(), leaving it in the same mostly-initialized state. The only difference is that the interpreter has some self-referential state that is statically initializexd to the main interpreter. We fix those fields here, in addition to the other dynamically initialized fields. */ static PyStatus init_interpreter(PyInterpreterState *interp, _PyRuntimeState *runtime, int64_t id, PyInterpreterState *next, long whence) { … } PyStatus _PyInterpreterState_New(PyThreadState *tstate, PyInterpreterState **pinterp) { … } PyInterpreterState * PyInterpreterState_New(void) { … } static void interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate) { … } void PyInterpreterState_Clear(PyInterpreterState *interp) { … } void _PyInterpreterState_Clear(PyThreadState *tstate) { … } static inline void tstate_deactivate(PyThreadState *tstate); static void tstate_set_detached(PyThreadState *tstate, int detached_state); static void zapthreads(PyInterpreterState *interp); void PyInterpreterState_Delete(PyInterpreterState *interp) { … } #ifdef HAVE_FORK /* * Delete all interpreter states except the main interpreter. If there * is a current interpreter state, it *must* be the main interpreter. */ PyStatus _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime) { … } #endif static inline void set_main_thread(PyInterpreterState *interp, PyThreadState *tstate) { … } static inline PyThreadState * get_main_thread(PyInterpreterState *interp) { … } int _PyInterpreterState_SetRunningMain(PyInterpreterState *interp) { … } void _PyInterpreterState_SetNotRunningMain(PyInterpreterState *interp) { … } int _PyInterpreterState_IsRunningMain(PyInterpreterState *interp) { … } int _PyThreadState_IsRunningMain(PyThreadState *tstate) { … } int _PyInterpreterState_FailIfRunningMain(PyInterpreterState *interp) { … } void _PyInterpreterState_ReinitRunningMain(PyThreadState *tstate) { … } //---------- // accessors //---------- int _PyInterpreterState_IsReady(PyInterpreterState *interp) { … } #ifndef NDEBUG static inline int check_interpreter_whence(long whence) { if(whence < 0) { return -1; } if (whence > _PyInterpreterState_WHENCE_MAX) { return -1; } return 0; } #endif long _PyInterpreterState_GetWhence(PyInterpreterState *interp) { … } void _PyInterpreterState_SetWhence(PyInterpreterState *interp, long whence) { … } PyObject * PyUnstable_InterpreterState_GetMainModule(PyInterpreterState *interp) { … } PyObject * PyInterpreterState_GetDict(PyInterpreterState *interp) { … } //---------- // interp ID //---------- int64_t _PyInterpreterState_ObjectToID(PyObject *idobj) { … } int64_t PyInterpreterState_GetID(PyInterpreterState *interp) { … } PyObject * _PyInterpreterState_GetIDObject(PyInterpreterState *interp) { … } void _PyInterpreterState_IDIncref(PyInterpreterState *interp) { … } void _PyInterpreterState_IDDecref(PyInterpreterState *interp) { … } int _PyInterpreterState_RequiresIDRef(PyInterpreterState *interp) { … } void _PyInterpreterState_RequireIDRef(PyInterpreterState *interp, int required) { … } //----------------------------- // look up an interpreter state //----------------------------- /* Return the interpreter associated with the current OS thread. The GIL must be held. */ PyInterpreterState* PyInterpreterState_Get(void) { … } static PyInterpreterState * interp_look_up_id(_PyRuntimeState *runtime, int64_t requested_id) { … } /* Return the interpreter state with the given ID. Fail with RuntimeError if the interpreter is not found. */ PyInterpreterState * _PyInterpreterState_LookUpID(int64_t requested_id) { … } PyInterpreterState * _PyInterpreterState_LookUpIDObject(PyObject *requested_id) { … } /********************************/ /* the per-thread runtime state */ /********************************/ #ifndef NDEBUG static inline int tstate_is_alive(PyThreadState *tstate) { return (tstate->_status.initialized && !tstate->_status.finalized && !tstate->_status.cleared && !tstate->_status.finalizing); } #endif //---------- // lifecycle //---------- /* Minimum size of data stack chunk */ #define DATA_STACK_CHUNK_SIZE … static _PyStackChunk* allocate_chunk(int size_in_bytes, _PyStackChunk* previous) { … } static _PyThreadStateImpl * alloc_threadstate(void) { … } static void free_threadstate(_PyThreadStateImpl *tstate) { … } /* Get the thread state to a minimal consistent state. Further init happens in pylifecycle.c before it can be used. All fields not initialized here are expected to be zeroed out, e.g. by PyMem_RawCalloc() or memset(), or otherwise pre-initialized. The interpreter state is not manipulated. Instead it is assumed that the thread is getting added to the interpreter. */ static void init_threadstate(_PyThreadStateImpl *_tstate, PyInterpreterState *interp, uint64_t id, int whence) { … } static void add_threadstate(PyInterpreterState *interp, PyThreadState *tstate, PyThreadState *next) { … } static PyThreadState * new_threadstate(PyInterpreterState *interp, int whence) { … } PyThreadState * PyThreadState_New(PyInterpreterState *interp) { … } PyThreadState * _PyThreadState_NewBound(PyInterpreterState *interp, int whence) { … } // This must be followed by a call to _PyThreadState_Bind(); PyThreadState * _PyThreadState_New(PyInterpreterState *interp, int whence) { … } // We keep this for stable ABI compabibility. PyAPI_FUNC(PyThreadState*) _PyThreadState_Prealloc(PyInterpreterState *interp) { … } // We keep this around for (accidental) stable ABI compatibility. // Realistically, no extensions are using it. PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *tstate) { … } static void clear_datastack(PyThreadState *tstate) { … } void PyThreadState_Clear(PyThreadState *tstate) { … } static void decrement_stoptheworld_countdown(struct _stoptheworld_state *stw); /* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */ static void tstate_delete_common(PyThreadState *tstate, int release_gil) { … } static void zapthreads(PyInterpreterState *interp) { … } void PyThreadState_Delete(PyThreadState *tstate) { … } void _PyThreadState_DeleteCurrent(PyThreadState *tstate) { … } void PyThreadState_DeleteCurrent(void) { … } // Unlinks and removes all thread states from `tstate->interp`, with the // exception of the one passed as an argument. However, it does not delete // these thread states. Instead, it returns the removed thread states as a // linked list. // // Note that if there is a current thread state, it *must* be the one // passed as argument. Also, this won't touch any interpreters other // than the current one, since we don't know which thread state should // be kept in those other interpreters. PyThreadState * _PyThreadState_RemoveExcept(PyThreadState *tstate) { … } // Deletes the thread states in the linked list `list`. // // This is intended to be used in conjunction with _PyThreadState_RemoveExcept. void _PyThreadState_DeleteList(PyThreadState *list) { … } //---------- // accessors //---------- /* An extension mechanism to store arbitrary additional per-thread state. PyThreadState_GetDict() returns a dictionary that can be used to hold such state; the caller should pick a unique key and store its state there. If PyThreadState_GetDict() returns NULL, an exception has *not* been raised and the caller should assume no per-thread state is available. */ PyObject * _PyThreadState_GetDict(PyThreadState *tstate) { … } PyObject * PyThreadState_GetDict(void) { … } PyInterpreterState * PyThreadState_GetInterpreter(PyThreadState *tstate) { … } PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate) { … } uint64_t PyThreadState_GetID(PyThreadState *tstate) { … } static inline void tstate_activate(PyThreadState *tstate) { … } static inline void tstate_deactivate(PyThreadState *tstate) { … } static int tstate_try_attach(PyThreadState *tstate) { … } static void tstate_set_detached(PyThreadState *tstate, int detached_state) { … } static void tstate_wait_attach(PyThreadState *tstate) { … } void _PyThreadState_Attach(PyThreadState *tstate) { … } static void detach_thread(PyThreadState *tstate, int detached_state) { … } void _PyThreadState_Detach(PyThreadState *tstate) { … } void _PyThreadState_Suspend(PyThreadState *tstate) { … } // Decrease stop-the-world counter of remaining number of threads that need to // pause. If we are the final thread to pause, notify the requesting thread. static void decrement_stoptheworld_countdown(struct _stoptheworld_state *stw) { … } #ifdef Py_GIL_DISABLED // Interpreter for _Py_FOR_EACH_THREAD(). For global stop-the-world events, // we start with the first interpreter and then iterate over all interpreters. // For per-interpreter stop-the-world events, we only operate on the one // interpreter. static PyInterpreterState * interp_for_stop_the_world(struct _stoptheworld_state *stw) { return (stw->is_global ? PyInterpreterState_Head() : _Py_CONTAINER_OF(stw, PyInterpreterState, stoptheworld)); } // Loops over threads for a stop-the-world event. // For global: all threads in all interpreters // For per-interpreter: all threads in the interpreter #define _Py_FOR_EACH_THREAD … // Try to transition threads atomically from the "detached" state to the // "gc stopped" state. Returns true if all threads are in the "gc stopped" static bool park_detached_threads(struct _stoptheworld_state *stw) { int num_parked = 0; PyInterpreterState *i; PyThreadState *t; _Py_FOR_EACH_THREAD(stw, i, t) { int state = _Py_atomic_load_int_relaxed(&t->state); if (state == _Py_THREAD_DETACHED) { // Atomically transition to "suspended" if in "detached" state. if (_Py_atomic_compare_exchange_int(&t->state, &state, _Py_THREAD_SUSPENDED)) { num_parked++; } } else if (state == _Py_THREAD_ATTACHED && t != stw->requester) { _Py_set_eval_breaker_bit(t, _PY_EVAL_PLEASE_STOP_BIT); } } stw->thread_countdown -= num_parked; assert(stw->thread_countdown >= 0); return num_parked > 0 && stw->thread_countdown == 0; } static void stop_the_world(struct _stoptheworld_state *stw) { _PyRuntimeState *runtime = &_PyRuntime; PyMutex_Lock(&stw->mutex); if (stw->is_global) { _PyRWMutex_Lock(&runtime->stoptheworld_mutex); } else { _PyRWMutex_RLock(&runtime->stoptheworld_mutex); } HEAD_LOCK(runtime); stw->requested = 1; stw->thread_countdown = 0; stw->stop_event = (PyEvent){0}; // zero-initialize (unset) stw->requester = _PyThreadState_GET(); // may be NULL PyInterpreterState *i; PyThreadState *t; _Py_FOR_EACH_THREAD(stw, i, t) { if (t != stw->requester) { // Count all the other threads (we don't wait on ourself). stw->thread_countdown++; } } if (stw->thread_countdown == 0) { HEAD_UNLOCK(runtime); stw->world_stopped = 1; return; } for (;;) { // Switch threads that are detached to the GC stopped state bool stopped_all_threads = park_detached_threads(stw); HEAD_UNLOCK(runtime); if (stopped_all_threads) { break; } PyTime_t wait_ns = 1000*1000; // 1ms (arbitrary, may need tuning) int detach = 0; if (PyEvent_WaitTimed(&stw->stop_event, wait_ns, detach)) { assert(stw->thread_countdown == 0); break; } HEAD_LOCK(runtime); } stw->world_stopped = 1; } static void start_the_world(struct _stoptheworld_state *stw) { _PyRuntimeState *runtime = &_PyRuntime; assert(PyMutex_IsLocked(&stw->mutex)); HEAD_LOCK(runtime); stw->requested = 0; stw->world_stopped = 0; // Switch threads back to the detached state. PyInterpreterState *i; PyThreadState *t; _Py_FOR_EACH_THREAD(stw, i, t) { if (t != stw->requester) { assert(_Py_atomic_load_int_relaxed(&t->state) == _Py_THREAD_SUSPENDED); _Py_atomic_store_int(&t->state, _Py_THREAD_DETACHED); _PyParkingLot_UnparkAll(&t->state); } } stw->requester = NULL; HEAD_UNLOCK(runtime); if (stw->is_global) { _PyRWMutex_Unlock(&runtime->stoptheworld_mutex); } else { _PyRWMutex_RUnlock(&runtime->stoptheworld_mutex); } PyMutex_Unlock(&stw->mutex); } #endif // Py_GIL_DISABLED void _PyEval_StopTheWorldAll(_PyRuntimeState *runtime) { … } void _PyEval_StartTheWorldAll(_PyRuntimeState *runtime) { … } void _PyEval_StopTheWorld(PyInterpreterState *interp) { … } void _PyEval_StartTheWorld(PyInterpreterState *interp) { … } //---------- // other API //---------- /* Asynchronously raise an exception in a thread. Requested by Just van Rossum and Alex Martelli. To prevent naive misuse, you must write your own extension to call this, or use ctypes. Must be called with the GIL held. Returns the number of tstates modified (normally 1, but 0 if `id` didn't match any known thread id). Can be called with exc=NULL to clear an existing async exception. This raises no exceptions. */ // XXX Move this to Python/ceval_gil.c? // XXX Deprecate this. int PyThreadState_SetAsyncExc(unsigned long id, PyObject *exc) { … } //--------------------------------- // API for the current thread state //--------------------------------- PyThreadState * PyThreadState_GetUnchecked(void) { … } PyThreadState * PyThreadState_Get(void) { … } PyThreadState * _PyThreadState_Swap(_PyRuntimeState *runtime, PyThreadState *newts) { … } PyThreadState * PyThreadState_Swap(PyThreadState *newts) { … } void _PyThreadState_Bind(PyThreadState *tstate) { … } #if defined(Py_GIL_DISABLED) && !defined(Py_LIMITED_API) uintptr_t _Py_GetThreadLocal_Addr(void) { #ifdef HAVE_THREAD_LOCAL // gh-112535: Use the address of the thread-local PyThreadState variable as // a unique identifier for the current thread. Each thread has a unique // _Py_tss_tstate variable with a unique address. return (uintptr_t)&_Py_tss_tstate; #else # error "no supported thread-local variable storage classifier" #endif } #endif /***********************************/ /* routines for advanced debuggers */ /***********************************/ // (requested by David Beazley) // Don't use unless you know what you are doing! PyInterpreterState * PyInterpreterState_Head(void) { … } PyInterpreterState * PyInterpreterState_Main(void) { … } PyInterpreterState * PyInterpreterState_Next(PyInterpreterState *interp) { … } PyThreadState * PyInterpreterState_ThreadHead(PyInterpreterState *interp) { … } PyThreadState * PyThreadState_Next(PyThreadState *tstate) { … } /********************************************/ /* reporting execution state of all threads */ /********************************************/ /* The implementation of sys._current_frames(). This is intended to be called with the GIL held, as it will be when called via sys._current_frames(). It's possible it would work fine even without the GIL held, but haven't thought enough about that. */ PyObject * _PyThread_CurrentFrames(void) { … } /* The implementation of sys._current_exceptions(). This is intended to be called with the GIL held, as it will be when called via sys._current_exceptions(). It's possible it would work fine even without the GIL held, but haven't thought enough about that. */ PyObject * _PyThread_CurrentExceptions(void) { … } /***********************************/ /* Python "auto thread state" API. */ /***********************************/ /* Internal initialization/finalization functions called by Py_Initialize/Py_FinalizeEx */ PyStatus _PyGILState_Init(PyInterpreterState *interp) { … } void _PyGILState_Fini(PyInterpreterState *interp) { … } // XXX Drop this. void _PyGILState_SetTstate(PyThreadState *tstate) { … } PyInterpreterState * _PyGILState_GetInterpreterStateUnsafe(void) { … } /* The public functions */ PyThreadState * PyGILState_GetThisThreadState(void) { … } int PyGILState_Check(void) { … } PyGILState_STATE PyGILState_Ensure(void) { … } void PyGILState_Release(PyGILState_STATE oldstate) { … } /*************/ /* Other API */ /*************/ _PyFrameEvalFunction _PyInterpreterState_GetEvalFrameFunc(PyInterpreterState *interp) { … } void _PyInterpreterState_SetEvalFrameFunc(PyInterpreterState *interp, _PyFrameEvalFunction eval_frame) { … } const PyConfig* _PyInterpreterState_GetConfig(PyInterpreterState *interp) { … } int _PyInterpreterState_GetConfigCopy(PyConfig *config) { … } const PyConfig* _Py_GetConfig(void) { … } int _PyInterpreterState_HasFeature(PyInterpreterState *interp, unsigned long feature) { … } #define MINIMUM_OVERHEAD … static PyObject ** push_chunk(PyThreadState *tstate, int size) { … } _PyInterpreterFrame * _PyThreadState_PushFrame(PyThreadState *tstate, size_t size) { … } void _PyThreadState_PopFrame(PyThreadState *tstate, _PyInterpreterFrame * frame) { … } #ifndef NDEBUG // Check that a Python thread state valid. In practice, this function is used // on a Python debug build to check if 'tstate' is a dangling pointer, if the // PyThreadState memory has been freed. // // Usage: // // assert(_PyThreadState_CheckConsistency(tstate)); int _PyThreadState_CheckConsistency(PyThreadState *tstate) { assert(!_PyMem_IsPtrFreed(tstate)); assert(!_PyMem_IsPtrFreed(tstate->interp)); return 1; } #endif // Check if a Python thread must exit immediately, rather than taking the GIL // if Py_Finalize() has been called. // // When this function is called by a daemon thread after Py_Finalize() has been // called, the GIL does no longer exist. // // tstate can be a dangling pointer (point to freed memory): only tstate value // is used, the pointer is not deferenced. // // tstate must be non-NULL. int _PyThreadState_MustExit(PyThreadState *tstate) { … } /********************/ /* mimalloc support */ /********************/ static void tstate_mimalloc_bind(PyThreadState *tstate) { … } void _PyThreadState_ClearMimallocHeaps(PyThreadState *tstate) { … }
Codebase Browser
cpython