#include "pycore_interp.h" // _PyInterpreterState.threads.stacksize #include "pycore_pythread.h" // _POSIX_SEMAPHORES #include "pycore_time.h" // _PyTime_FromMicrosecondsClamup() /* Posix threads interface */ #include <stdlib.h> #include <string.h> #if defined(__APPLE__) || defined(HAVE_PTHREAD_DESTRUCTOR) #define destructor … #endif #ifndef HAVE_PTHREAD_STUBS # include <pthread.h> #endif #if defined(__APPLE__) || defined(HAVE_PTHREAD_DESTRUCTOR) #undef destructor #endif #include <signal.h> #include <unistd.h> /* pause(), also getthrid() on OpenBSD */ #if defined(__linux__) # include <sys/syscall.h> /* syscall(SYS_gettid) */ #elif defined(__FreeBSD__) # include <pthread_np.h> /* pthread_getthreadid_np() */ #elif defined(__FreeBSD_kernel__) # include <sys/syscall.h> /* syscall(SYS_thr_self) */ #elif defined(_AIX) # include <sys/thread.h> /* thread_self() */ #elif defined(__NetBSD__) # include <lwp.h> /* _lwp_self() */ #elif defined(__DragonFly__) # include <sys/lwp.h> /* lwp_gettid() */ #endif /* The POSIX spec requires that use of pthread_attr_setstacksize be conditional on _POSIX_THREAD_ATTR_STACKSIZE being defined. */ #ifdef _POSIX_THREAD_ATTR_STACKSIZE #ifndef THREAD_STACK_SIZE #define THREAD_STACK_SIZE … #endif /* The default stack size for new threads on BSD is small enough that * we'll get hard crashes instead of 'maximum recursion depth exceeded' * exceptions. * * The default stack size below is the empirically determined minimal stack * sizes where a simple recursive function doesn't cause a hard crash. * * For macOS the value of THREAD_STACK_SIZE is determined in configure.ac * as it also depends on the other configure options like chosen sanitizer * runtimes. */ #if defined(__FreeBSD__) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0 #undef THREAD_STACK_SIZE #define THREAD_STACK_SIZE … #endif #if defined(_AIX) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0 #undef THREAD_STACK_SIZE #define THREAD_STACK_SIZE … #endif /* bpo-38852: test_threading.test_recursion_limit() checks that 1000 recursive Python calls (default recursion limit) doesn't crash, but raise a regular RecursionError exception. In debug mode, Python function calls allocates more memory on the stack, so use a stack of 8 MiB. */ #if defined(__ANDROID__) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0 # ifdef Py_DEBUG # undef THREAD_STACK_SIZE #define THREAD_STACK_SIZE … # endif #endif #if defined(__VXWORKS__) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0 #undef THREAD_STACK_SIZE #define THREAD_STACK_SIZE … #endif /* for safety, ensure a viable minimum stacksize */ #define THREAD_STACK_MIN … #else /* !_POSIX_THREAD_ATTR_STACKSIZE */ #ifdef THREAD_STACK_SIZE #error "THREAD_STACK_SIZE defined but _POSIX_THREAD_ATTR_STACKSIZE undefined" #endif #endif /* The POSIX spec says that implementations supporting the sem_* family of functions must indicate this by defining _POSIX_SEMAPHORES. */ #ifdef _POSIX_SEMAPHORES /* On FreeBSD 4.x, _POSIX_SEMAPHORES is defined empty, so we need to add 0 to make it work there as well. */ #if (_POSIX_SEMAPHORES+0) == -1 #define HAVE_BROKEN_POSIX_SEMAPHORES #else # include <semaphore.h> # include <errno.h> #endif #endif /* Thread sanitizer doesn't currently support sem_clockwait */ #ifdef _Py_THREAD_SANITIZER #undef HAVE_SEM_CLOCKWAIT #endif /* Whether or not to use semaphores directly rather than emulating them with * mutexes and condition variables: */ #if (defined(_POSIX_SEMAPHORES) && !defined(HAVE_BROKEN_POSIX_SEMAPHORES) && \ (defined(HAVE_SEM_TIMEDWAIT) || defined(HAVE_SEM_CLOCKWAIT))) #define USE_SEMAPHORES #else # undef USE_SEMAPHORES #endif /* On platforms that don't use standard POSIX threads pthread_sigmask() * isn't present. DEC threads uses sigprocmask() instead as do most * other UNIX International compliant systems that don't have the full * pthread implementation. */ #if defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK) #define SET_THREAD_SIGMASK … #else #define SET_THREAD_SIGMASK … #endif /* * pthread_cond support */ #define condattr_monotonic … static void init_condattr(void) { … } int _PyThread_cond_init(PyCOND_T *cond) { … } void _PyThread_cond_after(long long us, struct timespec *abs) { … } /* A pthread mutex isn't sufficient to model the Python lock type * because, according to Draft 5 of the docs (P1003.4a/D5), both of the * following are undefined: * -> a thread tries to lock a mutex it already has locked * -> a thread tries to unlock a mutex locked by a different thread * pthread mutexes are designed for serializing threads over short pieces * of code anyway, so wouldn't be an appropriate implementation of * Python's locks regardless. * * The pthread_lock struct implements a Python lock as a "locked?" bit * and a <condition, mutex> pair. In general, if the bit can be acquired * instantly, it is, else the pair is used to block the thread until the * bit is cleared. 9 May 1994 [email protected] */ pthread_lock; #define CHECK_STATUS(name) … #define CHECK_STATUS_PTHREAD(name) … /* * Initialization for the current runtime. */ static void PyThread__init_thread(void) { … } /* * Thread support. */ /* bpo-33015: pythread_callback struct and pythread_wrapper() cast "void func(void *)" to "void* func(void *)": always return NULL. PyThread_start_new_thread() uses "void func(void *)" type, whereas pthread_create() requires a void* return value. */ pythread_callback; static void * pythread_wrapper(void *arg) { … } static int do_start_joinable_thread(void (*func)(void *), void *arg, pthread_t* out_id) { … } int PyThread_start_joinable_thread(void (*func)(void *), void *arg, PyThread_ident_t* ident, PyThread_handle_t* handle) { … } unsigned long PyThread_start_new_thread(void (*func)(void *), void *arg) { … } int PyThread_join_thread(PyThread_handle_t th) { … } int PyThread_detach_thread(PyThread_handle_t th) { … } /* XXX This implementation is considered (to quote Tim Peters) "inherently hosed" because: - It does not guarantee the promise that a non-zero integer is returned. - The cast to unsigned long is inherently unsafe. - It is not clear that the 'volatile' (for AIX?) are any longer necessary. */ PyThread_ident_t PyThread_get_thread_ident_ex(void) { … } unsigned long PyThread_get_thread_ident(void) { … } #ifdef PY_HAVE_THREAD_NATIVE_ID unsigned long PyThread_get_thread_native_id(void) { … } #endif void _Py_NO_RETURN PyThread_exit_thread(void) { … } void _Py_NO_RETURN PyThread_hang_thread(void) { … } #ifdef USE_SEMAPHORES /* * Lock support. */ PyThread_type_lock PyThread_allocate_lock(void) { … } void PyThread_free_lock(PyThread_type_lock lock) { … } /* * As of February 2002, Cygwin thread implementations mistakenly report error * codes in the return value of the sem_ calls (like the pthread_ functions). * Correct implementations return -1 and put the code in errno. This supports * either. */ static int fix_status(int status) { … } PyLockStatus PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds, int intr_flag) { … } void PyThread_release_lock(PyThread_type_lock lock) { … } #else /* USE_SEMAPHORES */ /* * Lock support. */ PyThread_type_lock PyThread_allocate_lock(void) { pthread_lock *lock; int status, error = 0; if (!initialized) PyThread_init_thread(); lock = (pthread_lock *) PyMem_RawCalloc(1, sizeof(pthread_lock)); if (lock) { lock->locked = 0; status = pthread_mutex_init(&lock->mut, NULL); CHECK_STATUS_PTHREAD("pthread_mutex_init"); /* Mark the pthread mutex underlying a Python mutex as pure happens-before. We can't simply mark the Python-level mutex as a mutex because it can be acquired and released in different threads, which will cause errors. */ _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&lock->mut); status = _PyThread_cond_init(&lock->lock_released); CHECK_STATUS_PTHREAD("pthread_cond_init"); if (error) { PyMem_RawFree((void *)lock); lock = 0; } } return (PyThread_type_lock) lock; } void PyThread_free_lock(PyThread_type_lock lock) { pthread_lock *thelock = (pthread_lock *)lock; int status, error = 0; (void) error; /* silence unused-but-set-variable warning */ /* some pthread-like implementations tie the mutex to the cond * and must have the cond destroyed first. */ status = pthread_cond_destroy( &thelock->lock_released ); CHECK_STATUS_PTHREAD("pthread_cond_destroy"); status = pthread_mutex_destroy( &thelock->mut ); CHECK_STATUS_PTHREAD("pthread_mutex_destroy"); PyMem_RawFree((void *)thelock); } PyLockStatus PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds, int intr_flag) { PyLockStatus success = PY_LOCK_FAILURE; pthread_lock *thelock = (pthread_lock *)lock; int status, error = 0; if (microseconds == 0) { status = pthread_mutex_trylock( &thelock->mut ); if (status != EBUSY) { CHECK_STATUS_PTHREAD("pthread_mutex_trylock[1]"); } } else { status = pthread_mutex_lock( &thelock->mut ); CHECK_STATUS_PTHREAD("pthread_mutex_lock[1]"); } if (status != 0) { goto done; } if (thelock->locked == 0) { success = PY_LOCK_ACQUIRED; goto unlock; } if (microseconds == 0) { goto unlock; } struct timespec abs_timeout; if (microseconds > 0) { _PyThread_cond_after(microseconds, &abs_timeout); } // Continue trying until we get the lock // mut must be locked by me -- part of the condition protocol while (1) { if (microseconds > 0) { status = pthread_cond_timedwait(&thelock->lock_released, &thelock->mut, &abs_timeout); if (status == 1) { break; } if (status == ETIMEDOUT) { break; } CHECK_STATUS_PTHREAD("pthread_cond_timedwait"); } else { status = pthread_cond_wait( &thelock->lock_released, &thelock->mut); CHECK_STATUS_PTHREAD("pthread_cond_wait"); } if (intr_flag && status == 0 && thelock->locked) { // We were woken up, but didn't get the lock. We probably received // a signal. Return PY_LOCK_INTR to allow the caller to handle // it and retry. success = PY_LOCK_INTR; break; } if (status == 0 && !thelock->locked) { success = PY_LOCK_ACQUIRED; break; } // Wait got interrupted by a signal: retry } unlock: if (success == PY_LOCK_ACQUIRED) { thelock->locked = 1; } status = pthread_mutex_unlock( &thelock->mut ); CHECK_STATUS_PTHREAD("pthread_mutex_unlock[1]"); done: if (error) { success = PY_LOCK_FAILURE; } return success; } void PyThread_release_lock(PyThread_type_lock lock) { pthread_lock *thelock = (pthread_lock *)lock; int status, error = 0; (void) error; /* silence unused-but-set-variable warning */ status = pthread_mutex_lock( &thelock->mut ); CHECK_STATUS_PTHREAD("pthread_mutex_lock[3]"); thelock->locked = 0; /* wake up someone (anyone, if any) waiting on the lock */ status = pthread_cond_signal( &thelock->lock_released ); CHECK_STATUS_PTHREAD("pthread_cond_signal"); status = pthread_mutex_unlock( &thelock->mut ); CHECK_STATUS_PTHREAD("pthread_mutex_unlock[3]"); } #endif /* USE_SEMAPHORES */ int _PyThread_at_fork_reinit(PyThread_type_lock *lock) { … } int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag) { … } /* set the thread stack size. * Return 0 if size is valid, -1 if size is invalid, * -2 if setting stack size is not supported. */ static int _pythread_pthread_set_stacksize(size_t size) { … } #define THREAD_SET_STACKSIZE(x) … /* Thread Local Storage (TLS) API This API is DEPRECATED since Python 3.7. See PEP 539 for details. */ /* Issue #25658: On platforms where native TLS key is defined in a way that cannot be safely cast to int, PyThread_create_key returns immediately a failure status and other TLS functions all are no-ops. This indicates clearly that the old API is not supported on platforms where it cannot be used reliably, and that no effort will be made to add such support. Note: PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT will be unnecessary after removing this API. */ int PyThread_create_key(void) { … } void PyThread_delete_key(int key) { … } void PyThread_delete_key_value(int key) { … } int PyThread_set_key_value(int key, void *value) { … } void * PyThread_get_key_value(int key) { … } void PyThread_ReInitTLS(void) { … } /* Thread Specific Storage (TSS) API Platform-specific components of TSS API implementation. */ int PyThread_tss_create(Py_tss_t *key) { … } void PyThread_tss_delete(Py_tss_t *key) { … } int PyThread_tss_set(Py_tss_t *key, void *value) { … } void * PyThread_tss_get(Py_tss_t *key) { … }
Codebase Browser
cpython