2009-11-11 03:50:40 +08:00
|
|
|
/*
|
|
|
|
* Implementation of the Global Interpreter Lock (GIL).
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
|
|
|
|
/* First some general settings */
|
|
|
|
|
|
|
|
/* microseconds (the Python API uses seconds, though) */
|
|
|
|
#define DEFAULT_INTERVAL 5000
|
|
|
|
static unsigned long gil_interval = DEFAULT_INTERVAL;
|
|
|
|
#define INTERVAL (gil_interval >= 1 ? gil_interval : 1)
|
|
|
|
|
|
|
|
/* Enable if you want to force the switching of threads at least every `gil_interval` */
|
|
|
|
#undef FORCE_SWITCHING
|
|
|
|
#define FORCE_SWITCHING
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
Notes about the implementation:
|
|
|
|
|
|
|
|
- The GIL is just a boolean variable (gil_locked) whose access is protected
|
|
|
|
by a mutex (gil_mutex), and whose changes are signalled by a condition
|
|
|
|
variable (gil_cond). gil_mutex is taken for short periods of time,
|
|
|
|
and therefore mostly uncontended.
|
|
|
|
|
|
|
|
- In the GIL-holding thread, the main loop (PyEval_EvalFrameEx) must be
|
|
|
|
able to release the GIL on demand by another thread. A volatile boolean
|
|
|
|
variable (gil_drop_request) is used for that purpose, which is checked
|
|
|
|
at every turn of the eval loop. That variable is set after a wait of
|
|
|
|
`interval` microseconds on `gil_cond` has timed out.
|
|
|
|
|
|
|
|
[Actually, another volatile boolean variable (eval_breaker) is used
|
|
|
|
which ORs several conditions into one. Volatile booleans are
|
|
|
|
sufficient as inter-thread signalling means since Python is run
|
|
|
|
on cache-coherent architectures only.]
|
|
|
|
|
|
|
|
- A thread wanting to take the GIL will first let pass a given amount of
|
|
|
|
time (`interval` microseconds) before setting gil_drop_request. This
|
|
|
|
encourages a defined switching period, but doesn't enforce it since
|
|
|
|
opcodes can take an arbitrary time to execute.
|
|
|
|
|
|
|
|
The `interval` value is available for the user to read and modify
|
|
|
|
using the Python API `sys.{get,set}switchinterval()`.
|
|
|
|
|
|
|
|
- When a thread releases the GIL and gil_drop_request is set, that thread
|
|
|
|
ensures that another GIL-awaiting thread gets scheduled.
|
|
|
|
It does so by waiting on a condition variable (switch_cond) until
|
|
|
|
the value of gil_last_holder is changed to something else than its
|
|
|
|
own thread state pointer, indicating that another thread was able to
|
|
|
|
take the GIL.
|
|
|
|
|
|
|
|
This is meant to prohibit the latency-adverse behaviour on multi-core
|
|
|
|
machines where one thread would speculatively release the GIL, but still
|
|
|
|
run and end up being the first to re-acquire it, making the "timeslices"
|
|
|
|
much longer than expected.
|
|
|
|
(Note: this mechanism is enabled with FORCE_SWITCHING above)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _POSIX_THREADS
|
|
|
|
/* This means pthreads are not implemented in libc headers, hence the macro
|
|
|
|
not present in unistd.h. But they still can be implemented as an external
|
|
|
|
library (e.g. gnu pth in pthread emulation) */
|
|
|
|
# ifdef HAVE_PTHREAD_H
|
|
|
|
# include <pthread.h> /* _POSIX_THREADS */
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef _POSIX_THREADS
|
|
|
|
|
|
|
|
/*
|
|
|
|
* POSIX support
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <pthread.h>
|
|
|
|
|
|
|
|
#define ADD_MICROSECONDS(tv, interval) \
|
|
|
|
do { \
|
|
|
|
tv.tv_usec += (long) interval; \
|
|
|
|
tv.tv_sec += tv.tv_usec / 1000000; \
|
|
|
|
tv.tv_usec %= 1000000; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
/* We assume all modern POSIX systems have gettimeofday() */
|
|
|
|
#ifdef GETTIMEOFDAY_NO_TZ
|
|
|
|
#define GETTIMEOFDAY(ptv) gettimeofday(ptv)
|
|
|
|
#else
|
|
|
|
#define GETTIMEOFDAY(ptv) gettimeofday(ptv, (struct timezone *)NULL)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define MUTEX_T pthread_mutex_t
|
|
|
|
#define MUTEX_INIT(mut) \
|
|
|
|
if (pthread_mutex_init(&mut, NULL)) { \
|
|
|
|
Py_FatalError("pthread_mutex_init(" #mut ") failed"); };
|
2010-09-13 22:16:46 +08:00
|
|
|
#define MUTEX_FINI(mut) \
|
|
|
|
if (pthread_mutex_destroy(&mut)) { \
|
|
|
|
Py_FatalError("pthread_mutex_destroy(" #mut ") failed"); };
|
2009-11-11 03:50:40 +08:00
|
|
|
#define MUTEX_LOCK(mut) \
|
|
|
|
if (pthread_mutex_lock(&mut)) { \
|
|
|
|
Py_FatalError("pthread_mutex_lock(" #mut ") failed"); };
|
|
|
|
#define MUTEX_UNLOCK(mut) \
|
|
|
|
if (pthread_mutex_unlock(&mut)) { \
|
|
|
|
Py_FatalError("pthread_mutex_unlock(" #mut ") failed"); };
|
|
|
|
|
|
|
|
#define COND_T pthread_cond_t
|
|
|
|
#define COND_INIT(cond) \
|
|
|
|
if (pthread_cond_init(&cond, NULL)) { \
|
|
|
|
Py_FatalError("pthread_cond_init(" #cond ") failed"); };
|
2010-09-13 22:16:46 +08:00
|
|
|
#define COND_FINI(cond) \
|
|
|
|
if (pthread_cond_destroy(&cond)) { \
|
|
|
|
Py_FatalError("pthread_cond_destroy(" #cond ") failed"); };
|
2009-11-11 03:50:40 +08:00
|
|
|
#define COND_SIGNAL(cond) \
|
|
|
|
if (pthread_cond_signal(&cond)) { \
|
|
|
|
Py_FatalError("pthread_cond_signal(" #cond ") failed"); };
|
|
|
|
#define COND_WAIT(cond, mut) \
|
|
|
|
if (pthread_cond_wait(&cond, &mut)) { \
|
|
|
|
Py_FatalError("pthread_cond_wait(" #cond ") failed"); };
|
|
|
|
#define COND_TIMED_WAIT(cond, mut, microseconds, timeout_result) \
|
|
|
|
{ \
|
|
|
|
int r; \
|
|
|
|
struct timespec ts; \
|
|
|
|
struct timeval deadline; \
|
|
|
|
\
|
|
|
|
GETTIMEOFDAY(&deadline); \
|
|
|
|
ADD_MICROSECONDS(deadline, microseconds); \
|
|
|
|
ts.tv_sec = deadline.tv_sec; \
|
|
|
|
ts.tv_nsec = deadline.tv_usec * 1000; \
|
|
|
|
\
|
|
|
|
r = pthread_cond_timedwait(&cond, &mut, &ts); \
|
|
|
|
if (r == ETIMEDOUT) \
|
|
|
|
timeout_result = 1; \
|
|
|
|
else if (r) \
|
|
|
|
Py_FatalError("pthread_cond_timedwait(" #cond ") failed"); \
|
|
|
|
else \
|
|
|
|
timeout_result = 0; \
|
|
|
|
} \
|
|
|
|
|
|
|
|
#elif defined(NT_THREADS)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Windows (2000 and later, as well as (hopefully) CE) support
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <windows.h>
|
|
|
|
|
2010-08-10 21:48:51 +08:00
|
|
|
#define MUTEX_T CRITICAL_SECTION
|
|
|
|
#define MUTEX_INIT(mut) do { \
|
|
|
|
if (!(InitializeCriticalSectionAndSpinCount(&(mut), 4000))) \
|
|
|
|
Py_FatalError("CreateMutex(" #mut ") failed"); \
|
|
|
|
} while (0)
|
|
|
|
#define MUTEX_FINI(mut) \
|
|
|
|
DeleteCriticalSection(&(mut))
|
2009-11-11 03:50:40 +08:00
|
|
|
#define MUTEX_LOCK(mut) \
|
2010-08-10 21:48:51 +08:00
|
|
|
EnterCriticalSection(&(mut))
|
2009-11-11 03:50:40 +08:00
|
|
|
#define MUTEX_UNLOCK(mut) \
|
2010-08-10 21:48:51 +08:00
|
|
|
LeaveCriticalSection(&(mut))
|
|
|
|
|
|
|
|
/* We emulate condition variables with a semaphore.
|
|
|
|
We use a Semaphore rather than an auto-reset event, because although
|
|
|
|
an auto-resent event might appear to solve the lost-wakeup bug (race
|
|
|
|
condition between releasing the outer lock and waiting) because it
|
|
|
|
maintains state even though a wait hasn't happened, there is still
|
|
|
|
a lost wakeup problem if more than one thread are interrupted in the
|
|
|
|
critical place. A semaphore solves that.
|
|
|
|
Because it is ok to signal a condition variable with no one
|
|
|
|
waiting, we need to keep track of the number of
|
|
|
|
waiting threads. Otherwise, the semaphore's state could rise
|
|
|
|
without bound.
|
|
|
|
|
|
|
|
Generic emulations of the pthread_cond_* API using
|
2009-11-12 02:11:36 +08:00
|
|
|
Win32 functions can be found on the Web.
|
|
|
|
The following read can be edificating (or not):
|
|
|
|
http://www.cse.wustl.edu/~schmidt/win32-cv-1.html
|
|
|
|
*/
|
2010-08-10 21:48:51 +08:00
|
|
|
typedef struct COND_T
|
|
|
|
{
|
|
|
|
HANDLE sem; /* the semaphore */
|
|
|
|
int n_waiting; /* how many are unreleased */
|
|
|
|
} COND_T;
|
|
|
|
|
|
|
|
__inline static void _cond_init(COND_T *cond)
|
|
|
|
{
|
|
|
|
/* A semaphore with a large max value, The positive value
|
|
|
|
* is only needed to catch those "lost wakeup" events and
|
|
|
|
* race conditions when a timed wait elapses.
|
|
|
|
*/
|
|
|
|
if (!(cond->sem = CreateSemaphore(NULL, 0, 1000, NULL)))
|
|
|
|
Py_FatalError("CreateSemaphore() failed");
|
|
|
|
cond->n_waiting = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
__inline static void _cond_fini(COND_T *cond)
|
|
|
|
{
|
|
|
|
BOOL ok = CloseHandle(cond->sem);
|
|
|
|
if (!ok)
|
|
|
|
Py_FatalError("CloseHandle() failed");
|
|
|
|
}
|
|
|
|
|
|
|
|
__inline static void _cond_wait(COND_T *cond, MUTEX_T *mut)
|
|
|
|
{
|
|
|
|
++cond->n_waiting;
|
|
|
|
MUTEX_UNLOCK(*mut);
|
|
|
|
/* "lost wakeup bug" would occur if the caller were interrupted here,
|
|
|
|
* but we are safe because we are using a semaphore wich has an internal
|
|
|
|
* count.
|
|
|
|
*/
|
|
|
|
if (WaitForSingleObject(cond->sem, INFINITE) == WAIT_FAILED)
|
|
|
|
Py_FatalError("WaitForSingleObject() failed");
|
|
|
|
MUTEX_LOCK(*mut);
|
|
|
|
}
|
|
|
|
|
|
|
|
__inline static int _cond_timed_wait(COND_T *cond, MUTEX_T *mut,
|
|
|
|
int us)
|
|
|
|
{
|
|
|
|
DWORD r;
|
|
|
|
++cond->n_waiting;
|
|
|
|
MUTEX_UNLOCK(*mut);
|
|
|
|
r = WaitForSingleObject(cond->sem, us / 1000);
|
|
|
|
if (r == WAIT_FAILED)
|
|
|
|
Py_FatalError("WaitForSingleObject() failed");
|
|
|
|
MUTEX_LOCK(*mut);
|
|
|
|
if (r == WAIT_TIMEOUT)
|
|
|
|
--cond->n_waiting;
|
|
|
|
/* Here we have a benign race condition with _cond_signal. If the
|
|
|
|
* wait operation has timed out, but before we can acquire the
|
|
|
|
* mutex again to decrement n_waiting, a thread holding the mutex
|
|
|
|
* still sees a positive n_waiting value and may call
|
|
|
|
* ReleaseSemaphore and decrement n_waiting.
|
|
|
|
* This will cause n_waiting to be decremented twice.
|
|
|
|
* This is benign, though, because ReleaseSemaphore will also have
|
|
|
|
* been called, leaving the semaphore state positive. We may
|
|
|
|
* thus end up with semaphore in state 1, and n_waiting == -1, and
|
|
|
|
* the next time someone calls _cond_wait(), that thread will
|
|
|
|
* pass right through, decrementing the semaphore state and
|
|
|
|
* incrementing n_waiting, thus correcting the extra _cond_signal.
|
|
|
|
*/
|
|
|
|
return r == WAIT_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
__inline static void _cond_signal(COND_T *cond) {
|
|
|
|
/* NOTE: This must be called with the mutex held */
|
|
|
|
if (cond->n_waiting > 0) {
|
|
|
|
if (!ReleaseSemaphore(cond->sem, 1, NULL))
|
|
|
|
Py_FatalError("ReleaseSemaphore() failed");
|
|
|
|
--cond->n_waiting;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-11 03:50:40 +08:00
|
|
|
#define COND_INIT(cond) \
|
2010-08-10 21:48:51 +08:00
|
|
|
_cond_init(&(cond))
|
|
|
|
#define COND_FINI(cond) \
|
|
|
|
_cond_fini(&(cond))
|
2009-11-11 03:50:40 +08:00
|
|
|
#define COND_SIGNAL(cond) \
|
2010-08-10 21:48:51 +08:00
|
|
|
_cond_signal(&(cond))
|
2009-11-11 03:50:40 +08:00
|
|
|
#define COND_WAIT(cond, mut) \
|
2010-08-10 21:48:51 +08:00
|
|
|
_cond_wait(&(cond), &(mut))
|
|
|
|
#define COND_TIMED_WAIT(cond, mut, us, timeout_result) do { \
|
|
|
|
(timeout_result) = _cond_timed_wait(&(cond), &(mut), us); \
|
|
|
|
} while (0)
|
2009-11-11 03:50:40 +08:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#error You need either a POSIX-compatible or a Windows system!
|
|
|
|
|
|
|
|
#endif /* _POSIX_THREADS, NT_THREADS */
|
|
|
|
|
|
|
|
|
2010-05-04 03:29:34 +08:00
|
|
|
/* Whether the GIL is already taken (-1 if uninitialized). This is atomic
|
2009-11-11 03:50:40 +08:00
|
|
|
because it can be read without any lock taken in ceval.c. */
|
2010-05-04 03:29:34 +08:00
|
|
|
static _Py_atomic_int gil_locked = {-1};
|
2009-11-11 03:50:40 +08:00
|
|
|
/* Number of GIL switches since the beginning. */
|
|
|
|
static unsigned long gil_switch_number = 0;
|
2010-05-04 03:29:34 +08:00
|
|
|
/* Last PyThreadState holding / having held the GIL. This helps us know
|
|
|
|
whether anyone else was scheduled after we dropped the GIL. */
|
|
|
|
static _Py_atomic_address gil_last_holder = {NULL};
|
2009-11-11 03:50:40 +08:00
|
|
|
|
|
|
|
/* This condition variable allows one or several threads to wait until
|
|
|
|
the GIL is released. In addition, the mutex also protects the above
|
|
|
|
variables. */
|
|
|
|
static COND_T gil_cond;
|
|
|
|
static MUTEX_T gil_mutex;
|
|
|
|
|
|
|
|
#ifdef FORCE_SWITCHING
|
|
|
|
/* This condition variable helps the GIL-releasing thread wait for
|
|
|
|
a GIL-awaiting thread to be scheduled and take the GIL. */
|
|
|
|
static COND_T switch_cond;
|
|
|
|
static MUTEX_T switch_mutex;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
static int gil_created(void)
|
|
|
|
{
|
2010-05-04 03:29:34 +08:00
|
|
|
return _Py_atomic_load_explicit(&gil_locked, _Py_memory_order_acquire) >= 0;
|
2009-11-11 03:50:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void create_gil(void)
|
|
|
|
{
|
|
|
|
MUTEX_INIT(gil_mutex);
|
|
|
|
#ifdef FORCE_SWITCHING
|
|
|
|
MUTEX_INIT(switch_mutex);
|
|
|
|
#endif
|
|
|
|
COND_INIT(gil_cond);
|
|
|
|
#ifdef FORCE_SWITCHING
|
|
|
|
COND_INIT(switch_cond);
|
|
|
|
#endif
|
2010-05-04 03:29:34 +08:00
|
|
|
_Py_atomic_store_relaxed(&gil_last_holder, NULL);
|
|
|
|
_Py_ANNOTATE_RWLOCK_CREATE(&gil_locked);
|
|
|
|
_Py_atomic_store_explicit(&gil_locked, 0, _Py_memory_order_release);
|
2009-11-11 03:50:40 +08:00
|
|
|
}
|
|
|
|
|
2010-09-13 22:16:46 +08:00
|
|
|
static void destroy_gil(void)
|
|
|
|
{
|
|
|
|
MUTEX_FINI(gil_mutex);
|
|
|
|
#ifdef FORCE_SWITCHING
|
|
|
|
MUTEX_FINI(switch_mutex);
|
|
|
|
#endif
|
|
|
|
COND_FINI(gil_cond);
|
|
|
|
#ifdef FORCE_SWITCHING
|
|
|
|
COND_FINI(switch_cond);
|
|
|
|
#endif
|
|
|
|
_Py_atomic_store_explicit(&gil_locked, -1, _Py_memory_order_release);
|
|
|
|
_Py_ANNOTATE_RWLOCK_DESTROY(&gil_locked);
|
|
|
|
}
|
|
|
|
|
2009-11-11 03:50:40 +08:00
|
|
|
static void recreate_gil(void)
|
|
|
|
{
|
2010-05-04 03:29:34 +08:00
|
|
|
_Py_ANNOTATE_RWLOCK_DESTROY(&gil_locked);
|
2010-09-13 22:16:46 +08:00
|
|
|
/* XXX should we destroy the old OS resources here? */
|
2009-11-11 03:50:40 +08:00
|
|
|
create_gil();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drop_gil(PyThreadState *tstate)
|
|
|
|
{
|
2010-05-04 03:29:34 +08:00
|
|
|
if (!_Py_atomic_load_relaxed(&gil_locked))
|
2009-11-11 03:50:40 +08:00
|
|
|
Py_FatalError("drop_gil: GIL is not locked");
|
2011-01-15 19:37:11 +08:00
|
|
|
/* tstate is allowed to be NULL (early interpreter init) */
|
|
|
|
if (tstate != NULL) {
|
|
|
|
/* Sub-interpreter support: threads might have been switched
|
|
|
|
under our feet using PyThreadState_Swap(). Fix the GIL last
|
|
|
|
holder variable so that our heuristics work. */
|
|
|
|
_Py_atomic_store_relaxed(&gil_last_holder, tstate);
|
|
|
|
}
|
2009-11-11 03:50:40 +08:00
|
|
|
|
|
|
|
MUTEX_LOCK(gil_mutex);
|
2010-05-04 03:29:34 +08:00
|
|
|
_Py_ANNOTATE_RWLOCK_RELEASED(&gil_locked, /*is_write=*/1);
|
|
|
|
_Py_atomic_store_relaxed(&gil_locked, 0);
|
2009-11-11 03:50:40 +08:00
|
|
|
COND_SIGNAL(gil_cond);
|
|
|
|
MUTEX_UNLOCK(gil_mutex);
|
|
|
|
|
|
|
|
#ifdef FORCE_SWITCHING
|
2010-05-04 03:29:34 +08:00
|
|
|
if (_Py_atomic_load_relaxed(&gil_drop_request) && tstate != NULL) {
|
2009-11-11 03:50:40 +08:00
|
|
|
MUTEX_LOCK(switch_mutex);
|
|
|
|
/* Not switched yet => wait */
|
2010-05-04 03:29:34 +08:00
|
|
|
if (_Py_atomic_load_relaxed(&gil_last_holder) == tstate) {
|
2009-11-13 06:56:02 +08:00
|
|
|
RESET_GIL_DROP_REQUEST();
|
2009-11-12 02:11:36 +08:00
|
|
|
/* NOTE: if COND_WAIT does not atomically start waiting when
|
|
|
|
releasing the mutex, another thread can run through, take
|
|
|
|
the GIL and drop it again, and reset the condition
|
2009-11-13 06:56:02 +08:00
|
|
|
before we even had a chance to wait for it. */
|
2009-11-11 03:50:40 +08:00
|
|
|
COND_WAIT(switch_cond, switch_mutex);
|
2009-11-13 06:56:02 +08:00
|
|
|
}
|
2009-11-11 03:50:40 +08:00
|
|
|
MUTEX_UNLOCK(switch_mutex);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void take_gil(PyThreadState *tstate)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
if (tstate == NULL)
|
|
|
|
Py_FatalError("take_gil: NULL tstate");
|
|
|
|
|
|
|
|
err = errno;
|
|
|
|
MUTEX_LOCK(gil_mutex);
|
|
|
|
|
2010-05-04 03:29:34 +08:00
|
|
|
if (!_Py_atomic_load_relaxed(&gil_locked))
|
2009-11-11 03:50:40 +08:00
|
|
|
goto _ready;
|
|
|
|
|
2010-05-04 03:29:34 +08:00
|
|
|
while (_Py_atomic_load_relaxed(&gil_locked)) {
|
2009-11-11 03:50:40 +08:00
|
|
|
int timed_out = 0;
|
|
|
|
unsigned long saved_switchnum;
|
|
|
|
|
|
|
|
saved_switchnum = gil_switch_number;
|
|
|
|
COND_TIMED_WAIT(gil_cond, gil_mutex, INTERVAL, timed_out);
|
|
|
|
/* If we timed out and no switch occurred in the meantime, it is time
|
|
|
|
to ask the GIL-holding thread to drop it. */
|
2010-05-04 03:29:34 +08:00
|
|
|
if (timed_out &&
|
|
|
|
_Py_atomic_load_relaxed(&gil_locked) &&
|
|
|
|
gil_switch_number == saved_switchnum) {
|
2009-11-11 03:50:40 +08:00
|
|
|
SET_GIL_DROP_REQUEST();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ready:
|
|
|
|
#ifdef FORCE_SWITCHING
|
|
|
|
/* This mutex must be taken before modifying gil_last_holder (see drop_gil()). */
|
|
|
|
MUTEX_LOCK(switch_mutex);
|
|
|
|
#endif
|
|
|
|
/* We now hold the GIL */
|
2010-05-04 03:29:34 +08:00
|
|
|
_Py_atomic_store_relaxed(&gil_locked, 1);
|
|
|
|
_Py_ANNOTATE_RWLOCK_ACQUIRED(&gil_locked, /*is_write=*/1);
|
2009-11-11 03:50:40 +08:00
|
|
|
|
2010-05-04 03:29:34 +08:00
|
|
|
if (tstate != _Py_atomic_load_relaxed(&gil_last_holder)) {
|
|
|
|
_Py_atomic_store_relaxed(&gil_last_holder, tstate);
|
2009-11-11 03:50:40 +08:00
|
|
|
++gil_switch_number;
|
|
|
|
}
|
2010-05-04 03:29:34 +08:00
|
|
|
|
2009-11-11 03:50:40 +08:00
|
|
|
#ifdef FORCE_SWITCHING
|
|
|
|
COND_SIGNAL(switch_cond);
|
|
|
|
MUTEX_UNLOCK(switch_mutex);
|
|
|
|
#endif
|
2010-05-04 03:29:34 +08:00
|
|
|
if (_Py_atomic_load_relaxed(&gil_drop_request)) {
|
2009-11-11 03:50:40 +08:00
|
|
|
RESET_GIL_DROP_REQUEST();
|
|
|
|
}
|
|
|
|
if (tstate->async_exc != NULL) {
|
|
|
|
_PyEval_SignalAsyncExc();
|
|
|
|
}
|
|
|
|
|
|
|
|
MUTEX_UNLOCK(gil_mutex);
|
|
|
|
errno = err;
|
|
|
|
}
|
|
|
|
|
|
|
|
void _PyEval_SetSwitchInterval(unsigned long microseconds)
|
|
|
|
{
|
|
|
|
gil_interval = microseconds;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long _PyEval_GetSwitchInterval()
|
|
|
|
{
|
|
|
|
return gil_interval;
|
|
|
|
}
|