This is a precursor to the actual fix for gh-114940, where we will change these macros to use the new lock. This change is almost entirely mechanical; the exceptions are the loops in codeobject.c and ceval.c, which now hold the "head" lock. Note that almost all of the uses of _Py_FOR_EACH_TSTATE_UNLOCKED() here will change to _Py_FOR_EACH_TSTATE_BEGIN() once we add the new per-interpreter lock.
#define HEAD_UNLOCK(runtime) \
PyMutex_Unlock(&(runtime)->interpreters.mutex)
+#define _Py_FOR_EACH_TSTATE_UNLOCKED(interp, t) \
+ for (PyThreadState *t = interp->threads.head; t; t = t->next)
+#define _Py_FOR_EACH_TSTATE_BEGIN(interp, t) \
+ HEAD_LOCK(interp->runtime); \
+ _Py_FOR_EACH_TSTATE_UNLOCKED(interp, t)
+#define _Py_FOR_EACH_TSTATE_END(interp) \
+ HEAD_UNLOCK(interp->runtime)
+
+
// Get the configuration of the current interpreter.
// The caller must hold the GIL.
// Export for test_peg_generator.
assert(interp->stoptheworld.world_stopped);
assert(in_use->flags == NULL);
int32_t max_index = 0;
- for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, p) {
int32_t idx = ((_PyThreadStateImpl *) p)->tlbc_index;
if (idx > max_index) {
max_index = idx;
}
}
+ _Py_FOR_EACH_TSTATE_END(interp);
in_use->size = (size_t) max_index + 1;
in_use->flags = PyMem_Calloc(in_use->size, sizeof(*in_use->flags));
if (in_use->flags == NULL) {
return -1;
}
- for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, p) {
in_use->flags[((_PyThreadStateImpl *) p)->tlbc_index] = 1;
}
+ _Py_FOR_EACH_TSTATE_END(interp);
return 0;
}
since we can't determine which interpreter updated it. */
Py_ssize_t total = REFTOTAL(interp);
#ifdef Py_GIL_DISABLED
- for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(interp, p) {
/* This may race with other threads modifications to their reftotal */
_PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)p;
total += _Py_atomic_load_ssize_relaxed(&tstate_impl->reftotal);
{
size_t allocated_blocks = 0;
#ifdef Py_GIL_DISABLED
- for (PyThreadState *t = interp->threads.head; t != NULL; t = t->next) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(interp, t) {
_PyThreadStateImpl *tstate = (_PyThreadStateImpl *)t;
for (int i = 0; i < _Py_MIMALLOC_HEAP_COUNT; i++) {
mi_heap_t *heap = &tstate->mimalloc.heaps[i];
{
PyInterpreterState *interp = _PyInterpreterState_GET();
interp->ceval.recursion_limit = new_limit;
- for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, p) {
int depth = p->py_recursion_limit - p->py_recursion_remaining;
p->py_recursion_limit = new_limit;
p->py_recursion_remaining = new_limit - depth;
}
+ _Py_FOR_EACH_TSTATE_END(interp);
}
/* The function _Py_EnterRecursiveCallTstate() only calls _Py_CheckRecursiveCall()
void
_Py_set_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit)
{
- _PyRuntimeState *runtime = &_PyRuntime;
-
- HEAD_LOCK(runtime);
- for (PyThreadState *tstate = interp->threads.head; tstate != NULL; tstate = tstate->next) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, tstate) {
_Py_set_eval_breaker_bit(tstate, bit);
}
- HEAD_UNLOCK(runtime);
+ _Py_FOR_EACH_TSTATE_END(interp);
}
void
_Py_unset_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit)
{
- _PyRuntimeState *runtime = &_PyRuntime;
-
- HEAD_LOCK(runtime);
- for (PyThreadState *tstate = interp->threads.head; tstate != NULL; tstate = tstate->next) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, tstate) {
_Py_unset_eval_breaker_bit(tstate, bit);
}
- HEAD_UNLOCK(runtime);
+ _Py_FOR_EACH_TSTATE_END(interp);
}
void
Py_ssize_t offset_pre = offset_base + 2 * sizeof(PyObject*);
// visit each thread's heaps for GC objects
- for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(interp, p) {
struct _mimalloc_thread_state *m = &((_PyThreadStateImpl *)p)->mimalloc;
if (!_Py_atomic_load_int(&m->initialized)) {
// The thread may not have called tstate_mimalloc_bind() yet.
static void
gc_visit_thread_stacks(PyInterpreterState *interp)
{
- HEAD_LOCK(&_PyRuntime);
- for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, p) {
for (_PyInterpreterFrame *f = p->current_frame; f != NULL; f = f->previous) {
PyObject *executable = PyStackRef_AsPyObjectBorrow(f->f_executable);
if (executable == NULL || !PyCode_Check(executable)) {
}
}
}
- HEAD_UNLOCK(&_PyRuntime);
+ _Py_FOR_EACH_TSTATE_END(interp);
}
static void
// Merge the queues from other threads into our own queue so that we can
// process all of the pending delayed free requests at once.
- HEAD_LOCK(&_PyRuntime);
- for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, p) {
_PyThreadStateImpl *other = (_PyThreadStateImpl *)p;
if (other != current_tstate) {
llist_concat(¤t_tstate->mem_free_queue, &other->mem_free_queue);
}
}
- HEAD_UNLOCK(&_PyRuntime);
+ _Py_FOR_EACH_TSTATE_END(interp);
_PyMem_ProcessDelayedNoDealloc((PyThreadState *)current_tstate, queue_freed_object, state);
}
state->gcstate->old[i-1].count = 0;
}
- HEAD_LOCK(&_PyRuntime);
- for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, p) {
_PyThreadStateImpl *tstate = (_PyThreadStateImpl *)p;
// merge per-thread refcount for types into the type's actual refcount
// merge refcounts for all queued objects
merge_queued_objects(tstate, state);
}
- HEAD_UNLOCK(&_PyRuntime);
+ _Py_FOR_EACH_TSTATE_END(interp);
process_delayed_frees(interp, state);
void
_PyGC_ClearAllFreeLists(PyInterpreterState *interp)
{
- HEAD_LOCK(&_PyRuntime);
- _PyThreadStateImpl *tstate = (_PyThreadStateImpl *)interp->threads.head;
- while (tstate != NULL) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, p) {
+ _PyThreadStateImpl *tstate = (_PyThreadStateImpl *)p;
_PyObject_ClearFreeLists(&tstate->freelists, 0);
- tstate = (_PyThreadStateImpl *)tstate->base.next;
}
- HEAD_UNLOCK(&_PyRuntime);
+ _Py_FOR_EACH_TSTATE_END(interp);
}
#endif // Py_GIL_DISABLED
#ifdef Py_GIL_DISABLED
// Set the version on all threads in free-threaded builds.
- _PyRuntimeState *runtime = &_PyRuntime;
- HEAD_LOCK(runtime);
- for (tstate = interp->threads.head; tstate;
- tstate = PyThreadState_Next(tstate)) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, tstate) {
set_version_raw(&tstate->eval_breaker, version);
};
- HEAD_UNLOCK(runtime);
+ _Py_FOR_EACH_TSTATE_END(interp);
#else
// Normal builds take the current version from instrumentation_version when
// attaching a thread, so we only have to set the current thread's version.
}
// Clear the current/main thread state last.
- HEAD_LOCK(runtime);
- PyThreadState *p = interp->threads.head;
- HEAD_UNLOCK(runtime);
- while (p != NULL) {
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, p) {
// See https://github.com/python/cpython/issues/102126
// Must be called without HEAD_LOCK held as it can deadlock
// if any finalizer tries to acquire that lock.
+ HEAD_UNLOCK(runtime);
PyThreadState_Clear(p);
HEAD_LOCK(runtime);
- p = p->next;
- HEAD_UNLOCK(runtime);
}
+ _Py_FOR_EACH_TSTATE_END(interp);
if (tstate->interp == interp) {
/* We fix tstate->_status below when we for sure aren't using it
(e.g. no longer need the GIL). */
static void
zapthreads(PyInterpreterState *interp)
{
- PyThreadState *tstate;
/* No need to lock the mutex here because this should only happen
when the threads are all really dead (XXX famous last words). */
- while ((tstate = interp->threads.head) != NULL) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(interp, tstate) {
tstate_verify_not_active(tstate);
tstate_delete_common(tstate, 0);
free_threadstate((_PyThreadStateImpl *)tstate);
}
#ifdef Py_GIL_DISABLED
-// Interpreter for _Py_FOR_EACH_THREAD(). For global stop-the-world events,
+// Interpreter for _Py_FOR_EACH_STW_INTERP(). 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.
// 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(stw, i, t) \
- for (i = interp_for_stop_the_world((stw)); \
- i != NULL; i = ((stw->is_global) ? i->next : NULL)) \
- for (t = i->threads.head; t; t = t->next)
+#define _Py_FOR_EACH_STW_INTERP(stw, i) \
+ for (PyInterpreterState *i = interp_for_stop_the_world((stw)); \
+ i != NULL; i = ((stw->is_global) ? i->next : NULL))
// Try to transition threads atomically from the "detached" state to the
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++;
+ _Py_FOR_EACH_STW_INTERP(stw, i) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(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);
}
- }
- 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;
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++;
+ _Py_FOR_EACH_STW_INTERP(stw, i) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(i, t) {
+ if (t != stw->requester) {
+ // Count all the other threads (we don't wait on ourself).
+ stw->thread_countdown++;
+ }
}
}
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);
+ _Py_FOR_EACH_STW_INTERP(stw, i) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(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;
int
PyThreadState_SetAsyncExc(unsigned long id, PyObject *exc)
{
- _PyRuntimeState *runtime = &_PyRuntime;
PyInterpreterState *interp = _PyInterpreterState_GET();
/* Although the GIL is held, a few C API functions can be called
* list of thread states we're traversing, so to prevent that we lock
* head_mutex for the duration.
*/
- HEAD_LOCK(runtime);
- for (PyThreadState *tstate = interp->threads.head; tstate != NULL; tstate = tstate->next) {
- if (tstate->thread_id != id) {
- continue;
+ PyThreadState *tstate = NULL;
+ _Py_FOR_EACH_TSTATE_BEGIN(interp, t) {
+ if (t->thread_id == id) {
+ tstate = t;
+ break;
}
+ }
+ _Py_FOR_EACH_TSTATE_END(interp);
+ if (tstate != NULL) {
/* Tricky: we need to decref the current value
* (if any) in tstate->async_exc, but that can in turn
* allow arbitrary Python code to run, including
*/
Py_XINCREF(exc);
PyObject *old_exc = _Py_atomic_exchange_ptr(&tstate->async_exc, exc);
- HEAD_UNLOCK(runtime);
Py_XDECREF(old_exc);
_Py_set_eval_breaker_bit(tstate, _PY_ASYNC_EXCEPTION_BIT);
- return 1;
}
- HEAD_UNLOCK(runtime);
- return 0;
+
+ return tstate != NULL;
}
//---------------------------------
HEAD_LOCK(runtime);
PyInterpreterState *i;
for (i = runtime->interpreters.head; i != NULL; i = i->next) {
- PyThreadState *t;
- for (t = i->threads.head; t != NULL; t = t->next) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(i, t) {
_PyInterpreterFrame *frame = t->current_frame;
frame = _PyFrame_GetFirstComplete(frame);
if (frame == NULL) {
HEAD_LOCK(runtime);
PyInterpreterState *i;
for (i = runtime->interpreters.head; i != NULL; i = i->next) {
- PyThreadState *t;
- for (t = i->threads.head; t != NULL; t = t->next) {
+ _Py_FOR_EACH_TSTATE_UNLOCKED(i, t) {
_PyErr_StackItem *err_info = _PyErr_GetTopmostException(t);
if (err_info == NULL) {
continue;
projects / thirdparty / Python / cpython.git / commitdiff
