diff options
author | Victor Stinner <vstinner@redhat.com> | 2019-03-04 13:21:28 (GMT) |
---|---|---|
committer | GitHub <noreply@github.com> | 2019-03-04 13:21:28 (GMT) |
commit | 4d61e6e3b802399be62a521d6fa785698cb670b5 (patch) | |
tree | 9eb5258b1479331b29b9ce00e6b55c1dc01f9d06 /Python/ceval.c | |
parent | f4b0a1c0da80318e0a4f4c70d2722f01ce3512dd (diff) | |
download | cpython-4d61e6e3b802399be62a521d6fa785698cb670b5.zip cpython-4d61e6e3b802399be62a521d6fa785698cb670b5.tar.gz cpython-4d61e6e3b802399be62a521d6fa785698cb670b5.tar.bz2 |
Revert: bpo-33608: Factor out a private, per-interpreter _Py_AddPendingCall(). (GH-11617) (GH-12159)
* Revert "bpo-36097: Use only public C-API in the_xxsubinterpreters module (adding as necessary). (#12003)"
This reverts commit bcfa450f210074e16feb761ae5b3e966a2532fcf.
* Revert "bpo-33608: Simplify ceval's DISPATCH by hoisting eval_breaker ahead of time. (gh-12062)"
This reverts commit bda918bf65a88560ec453aaba0758a9c0d49b449.
* Revert "bpo-33608: Use _Py_AddPendingCall() in _PyCrossInterpreterData_Release(). (gh-12024)"
This reverts commit b05b711a2cef6c6c381e01069dedac372e0b9fb2.
* Revert "bpo-33608: Factor out a private, per-interpreter _Py_AddPendingCall(). (GH-11617)"
This reverts commit ef4ac967e2f3a9a18330cc6abe14adb4bc3d0465.
Diffstat (limited to 'Python/ceval.c')
-rw-r--r-- | Python/ceval.c | 200 |
1 files changed, 82 insertions, 118 deletions
diff --git a/Python/ceval.c b/Python/ceval.c index be75ade..b311248 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -96,61 +96,61 @@ static long dxp[256]; /* This can set eval_breaker to 0 even though gil_drop_request became 1. We believe this is all right because the eval loop will release the GIL eventually anyway. */ -#define COMPUTE_EVAL_BREAKER(interp) \ +#define COMPUTE_EVAL_BREAKER() \ _Py_atomic_store_relaxed( \ - &interp->ceval.eval_breaker, \ + &_PyRuntime.ceval.eval_breaker, \ GIL_REQUEST | \ _Py_atomic_load_relaxed(&_PyRuntime.ceval.signals_pending) | \ - _Py_atomic_load_relaxed(&interp->ceval.pending.calls_to_do) | \ - interp->ceval.pending.async_exc) + _Py_atomic_load_relaxed(&_PyRuntime.ceval.pending.calls_to_do) | \ + _PyRuntime.ceval.pending.async_exc) -#define SET_GIL_DROP_REQUEST(interp) \ +#define SET_GIL_DROP_REQUEST() \ do { \ _Py_atomic_store_relaxed(&_PyRuntime.ceval.gil_drop_request, 1); \ - _Py_atomic_store_relaxed(&interp->ceval.eval_breaker, 1); \ + _Py_atomic_store_relaxed(&_PyRuntime.ceval.eval_breaker, 1); \ } while (0) -#define RESET_GIL_DROP_REQUEST(interp) \ +#define RESET_GIL_DROP_REQUEST() \ do { \ _Py_atomic_store_relaxed(&_PyRuntime.ceval.gil_drop_request, 0); \ - COMPUTE_EVAL_BREAKER(interp); \ + COMPUTE_EVAL_BREAKER(); \ } while (0) /* Pending calls are only modified under pending_lock */ -#define SIGNAL_PENDING_CALLS(interp) \ +#define SIGNAL_PENDING_CALLS() \ do { \ - _Py_atomic_store_relaxed(&interp->ceval.pending.calls_to_do, 1); \ - _Py_atomic_store_relaxed(&interp->ceval.eval_breaker, 1); \ + _Py_atomic_store_relaxed(&_PyRuntime.ceval.pending.calls_to_do, 1); \ + _Py_atomic_store_relaxed(&_PyRuntime.ceval.eval_breaker, 1); \ } while (0) -#define UNSIGNAL_PENDING_CALLS(interp) \ +#define UNSIGNAL_PENDING_CALLS() \ do { \ - _Py_atomic_store_relaxed(&interp->ceval.pending.calls_to_do, 0); \ - COMPUTE_EVAL_BREAKER(interp); \ + _Py_atomic_store_relaxed(&_PyRuntime.ceval.pending.calls_to_do, 0); \ + COMPUTE_EVAL_BREAKER(); \ } while (0) #define SIGNAL_PENDING_SIGNALS() \ do { \ _Py_atomic_store_relaxed(&_PyRuntime.ceval.signals_pending, 1); \ - _Py_atomic_store_relaxed(&_PyRuntime.interpreters.main->ceval.eval_breaker, 1); \ + _Py_atomic_store_relaxed(&_PyRuntime.ceval.eval_breaker, 1); \ } while (0) #define UNSIGNAL_PENDING_SIGNALS() \ do { \ _Py_atomic_store_relaxed(&_PyRuntime.ceval.signals_pending, 0); \ - COMPUTE_EVAL_BREAKER(_PyRuntime.interpreters.main); \ + COMPUTE_EVAL_BREAKER(); \ } while (0) -#define SIGNAL_ASYNC_EXC(interp) \ +#define SIGNAL_ASYNC_EXC() \ do { \ - interp->ceval.pending.async_exc = 1; \ - _Py_atomic_store_relaxed(&interp->ceval.eval_breaker, 1); \ + _PyRuntime.ceval.pending.async_exc = 1; \ + _Py_atomic_store_relaxed(&_PyRuntime.ceval.eval_breaker, 1); \ } while (0) -#define UNSIGNAL_ASYNC_EXC(interp) \ +#define UNSIGNAL_ASYNC_EXC() \ do { \ - interp->ceval.pending.async_exc = 0; \ - COMPUTE_EVAL_BREAKER(interp); \ + _PyRuntime.ceval.pending.async_exc = 0; \ + COMPUTE_EVAL_BREAKER(); \ } while (0) @@ -174,6 +174,9 @@ PyEval_InitThreads(void) PyThread_init_thread(); create_gil(); take_gil(_PyThreadState_GET()); + _PyRuntime.ceval.pending.main_thread = PyThread_get_thread_ident(); + if (!_PyRuntime.ceval.pending.lock) + _PyRuntime.ceval.pending.lock = PyThread_allocate_lock(); } void @@ -240,11 +243,9 @@ PyEval_ReInitThreads(void) if (!gil_created()) return; recreate_gil(); - // This will be reset in make_pending_calls() below. - current_tstate->interp->ceval.pending.lock = NULL; - + _PyRuntime.ceval.pending.lock = PyThread_allocate_lock(); take_gil(current_tstate); - _PyRuntime.main_thread = PyThread_get_thread_ident(); + _PyRuntime.ceval.pending.main_thread = PyThread_get_thread_ident(); /* Destroy all threads except the current one */ _PyThreadState_DeleteExcept(current_tstate); @@ -254,9 +255,9 @@ PyEval_ReInitThreads(void) raised. */ void -_PyEval_SignalAsyncExc(PyInterpreterState *interp) +_PyEval_SignalAsyncExc(void) { - SIGNAL_ASYNC_EXC(interp); + SIGNAL_ASYNC_EXC(); } PyThreadState * @@ -322,58 +323,17 @@ _PyEval_SignalReceived(void) SIGNAL_PENDING_SIGNALS(); } -static int -_add_pending_call(PyInterpreterState *interp, unsigned long thread_id, int (*func)(void *), void *arg) -{ - int i = interp->ceval.pending.last; - int j = (i + 1) % NPENDINGCALLS; - if (j == interp->ceval.pending.first) { - return -1; /* Queue full */ - } - interp->ceval.pending.calls[i].thread_id = thread_id; - interp->ceval.pending.calls[i].func = func; - interp->ceval.pending.calls[i].arg = arg; - interp->ceval.pending.last = j; - return 0; -} - -/* pop one item off the queue while holding the lock */ -static void -_pop_pending_call(PyInterpreterState *interp, int (**func)(void *), void **arg) -{ - int i = interp->ceval.pending.first; - if (i == interp->ceval.pending.last) { - return; /* Queue empty */ - } - - *func = interp->ceval.pending.calls[i].func; - *arg = interp->ceval.pending.calls[i].arg; - interp->ceval.pending.first = (i + 1) % NPENDINGCALLS; - - unsigned long thread_id = interp->ceval.pending.calls[i].thread_id; - if (thread_id && PyThread_get_thread_ident() != thread_id) { - // Thread mismatch, so move it to the end of the list - // and start over. - _Py_AddPendingCall(interp, thread_id, *func, *arg); - return; - } -} - -int -Py_AddPendingCall(int (*func)(void *), void *arg) -{ - PyInterpreterState *interp = _PyRuntime.interpreters.main; - return _Py_AddPendingCall(interp, _PyRuntime.main_thread, func, arg); -} - /* This implementation is thread-safe. It allows scheduling to be made from any thread, and even from an executing callback. */ int -_Py_AddPendingCall(PyInterpreterState *interp, unsigned long thread_id, int (*func)(void *), void *arg) +Py_AddPendingCall(int (*func)(void *), void *arg) { + int i, j, result=0; + PyThread_type_lock lock = _PyRuntime.ceval.pending.lock; + /* try a few times for the lock. Since this mechanism is used * for signal handling (on the main thread), there is a (slim) * chance that a signal is delivered on the same thread while we @@ -385,9 +345,7 @@ _Py_AddPendingCall(PyInterpreterState *interp, unsigned long thread_id, int (*fu * We also check for lock being NULL, in the unlikely case that * this function is called before any bytecode evaluation takes place. */ - PyThread_type_lock lock = interp->ceval.pending.lock; if (lock != NULL) { - int i; for (i = 0; i<100; i++) { if (PyThread_acquire_lock(lock, NOWAIT_LOCK)) break; @@ -396,21 +354,17 @@ _Py_AddPendingCall(PyInterpreterState *interp, unsigned long thread_id, int (*fu return -1; } - int result = -1; - if (interp->finalizing) { - PyObject *exc, *val, *tb; - PyErr_Fetch(&exc, &val, &tb); - PyErr_SetString(PyExc_SystemError, "Py_AddPendingCall: cannot add pending calls (interpreter shutting down)"); - PyErr_Print(); - PyErr_Restore(exc, val, tb); - goto done; + i = _PyRuntime.ceval.pending.last; + j = (i + 1) % NPENDINGCALLS; + if (j == _PyRuntime.ceval.pending.first) { + result = -1; /* Queue full */ + } else { + _PyRuntime.ceval.pending.calls[i].func = func; + _PyRuntime.ceval.pending.calls[i].arg = arg; + _PyRuntime.ceval.pending.last = j; } - - result = _add_pending_call(interp, thread_id, func, arg); /* signal main loop */ - SIGNAL_PENDING_CALLS(interp); - -done: + SIGNAL_PENDING_CALLS(); if (lock != NULL) PyThread_release_lock(lock); return result; @@ -420,7 +374,9 @@ static int handle_signals(void) { /* Only handle signals on main thread. */ - if (PyThread_get_thread_ident() != _PyRuntime.main_thread) { + if (_PyRuntime.ceval.pending.main_thread && + PyThread_get_thread_ident() != _PyRuntime.ceval.pending.main_thread) + { return 0; } /* @@ -440,10 +396,17 @@ handle_signals(void) } static int -make_pending_calls(PyInterpreterState *interp) +make_pending_calls(void) { static int busy = 0; + /* only service pending calls on main thread */ + if (_PyRuntime.ceval.pending.main_thread && + PyThread_get_thread_ident() != _PyRuntime.ceval.pending.main_thread) + { + return 0; + } + /* don't perform recursive pending calls */ if (busy) { return 0; @@ -451,13 +414,13 @@ make_pending_calls(PyInterpreterState *interp) busy = 1; /* unsignal before starting to call callbacks, so that any callback added in-between re-signals */ - UNSIGNAL_PENDING_CALLS(interp); + UNSIGNAL_PENDING_CALLS(); int res = 0; - if (!interp->ceval.pending.lock) { + if (!_PyRuntime.ceval.pending.lock) { /* initial allocation of the lock */ - interp->ceval.pending.lock = PyThread_allocate_lock(); - if (interp->ceval.pending.lock == NULL) { + _PyRuntime.ceval.pending.lock = PyThread_allocate_lock(); + if (_PyRuntime.ceval.pending.lock == NULL) { res = -1; goto error; } @@ -465,18 +428,24 @@ make_pending_calls(PyInterpreterState *interp) /* perform a bounded number of calls, in case of recursion */ for (int i=0; i<NPENDINGCALLS; i++) { - int (*func)(void *) = NULL; + int j; + int (*func)(void *); void *arg = NULL; /* pop one item off the queue while holding the lock */ - PyThread_acquire_lock(interp->ceval.pending.lock, WAIT_LOCK); - _pop_pending_call(interp, &func, &arg); - PyThread_release_lock(interp->ceval.pending.lock); - + PyThread_acquire_lock(_PyRuntime.ceval.pending.lock, WAIT_LOCK); + j = _PyRuntime.ceval.pending.first; + if (j == _PyRuntime.ceval.pending.last) { + func = NULL; /* Queue empty */ + } else { + func = _PyRuntime.ceval.pending.calls[j].func; + arg = _PyRuntime.ceval.pending.calls[j].arg; + _PyRuntime.ceval.pending.first = (j + 1) % NPENDINGCALLS; + } + PyThread_release_lock(_PyRuntime.ceval.pending.lock); /* having released the lock, perform the callback */ - if (func == NULL) { + if (func == NULL) break; - } res = func(arg); if (res) { goto error; @@ -488,18 +457,10 @@ make_pending_calls(PyInterpreterState *interp) error: busy = 0; - SIGNAL_PENDING_CALLS(interp); /* We're not done yet */ + SIGNAL_PENDING_CALLS(); return res; } -int -_Py_MakePendingCalls(PyInterpreterState *interp) -{ - assert(PyGILState_Check()); - - return make_pending_calls(interp); -} - /* Py_MakePendingCalls() is a simple wrapper for the sake of backward-compatibility. */ int @@ -514,8 +475,12 @@ Py_MakePendingCalls(void) return res; } - PyInterpreterState *interp = _PyRuntime.interpreters.main; - return make_pending_calls(interp); + res = make_pending_calls(); + if (res != 0) { + return res; + } + + return 0; } /* The interpreter's recursion limit */ @@ -637,7 +602,6 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag) PyObject **fastlocals, **freevars; PyObject *retval = NULL; /* Return value */ PyThreadState *tstate = _PyThreadState_GET(); - _Py_atomic_int *eval_breaker = &tstate->interp->ceval.eval_breaker; PyCodeObject *co; /* when tracing we set things up so that @@ -723,7 +687,7 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag) #define DISPATCH() \ { \ - if (!_Py_atomic_load_relaxed(eval_breaker)) { \ + if (!_Py_atomic_load_relaxed(&_PyRuntime.ceval.eval_breaker)) { \ FAST_DISPATCH(); \ } \ continue; \ @@ -1025,7 +989,7 @@ main_loop: async I/O handler); see Py_AddPendingCall() and Py_MakePendingCalls() above. */ - if (_Py_atomic_load_relaxed(eval_breaker)) { + if (_Py_atomic_load_relaxed(&_PyRuntime.ceval.eval_breaker)) { opcode = _Py_OPCODE(*next_instr); if (opcode == SETUP_FINALLY || opcode == SETUP_WITH || @@ -1058,9 +1022,9 @@ main_loop: } } if (_Py_atomic_load_relaxed( - &(tstate->interp->ceval.pending.calls_to_do))) + &_PyRuntime.ceval.pending.calls_to_do)) { - if (_Py_MakePendingCalls(tstate->interp) != 0) { + if (make_pending_calls() != 0) { goto error; } } @@ -1092,7 +1056,7 @@ main_loop: if (tstate->async_exc != NULL) { PyObject *exc = tstate->async_exc; tstate->async_exc = NULL; - UNSIGNAL_ASYNC_EXC(tstate->interp); + UNSIGNAL_ASYNC_EXC(); PyErr_SetNone(exc); Py_DECREF(exc); goto error; |