mirror of
https://github.com/python/cpython.git
synced 2024-12-25 01:34:48 +08:00
05351c1bd8
Windows buildbots started failing due to include-related errors.
237 lines
6.5 KiB
C
237 lines
6.5 KiB
C
|
|
/* Thread package.
|
|
This is intended to be usable independently from Python.
|
|
The implementation for system foobar is in a file thread_foobar.h
|
|
which is included by this file dependent on config settings.
|
|
Stuff shared by all thread_*.h files is collected here. */
|
|
|
|
#include "Python.h"
|
|
|
|
#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
|
|
|
|
#ifndef DONT_HAVE_STDIO_H
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "pythread.h"
|
|
|
|
#ifndef _POSIX_THREADS
|
|
|
|
/* Check if we're running on HP-UX and _SC_THREADS is defined. If so, then
|
|
enough of the Posix threads package is implemented to support python
|
|
threads.
|
|
|
|
This is valid for HP-UX 11.23 running on an ia64 system. If needed, add
|
|
a check of __ia64 to verify that we're running on an ia64 system instead
|
|
of a pa-risc system.
|
|
*/
|
|
#ifdef __hpux
|
|
#ifdef _SC_THREADS
|
|
#define _POSIX_THREADS
|
|
#endif
|
|
#endif
|
|
|
|
#endif /* _POSIX_THREADS */
|
|
|
|
|
|
#ifdef Py_DEBUG
|
|
static int thread_debug = 0;
|
|
#define dprintf(args) (void)((thread_debug & 1) && printf args)
|
|
#define d2printf(args) ((thread_debug & 8) && printf args)
|
|
#else
|
|
#define dprintf(args)
|
|
#define d2printf(args)
|
|
#endif
|
|
|
|
static int initialized;
|
|
|
|
static void PyThread__init_thread(void); /* Forward */
|
|
|
|
void
|
|
PyThread_init_thread(void)
|
|
{
|
|
#ifdef Py_DEBUG
|
|
char *p = Py_GETENV("PYTHONTHREADDEBUG");
|
|
|
|
if (p) {
|
|
if (*p)
|
|
thread_debug = atoi(p);
|
|
else
|
|
thread_debug = 1;
|
|
}
|
|
#endif /* Py_DEBUG */
|
|
if (initialized)
|
|
return;
|
|
initialized = 1;
|
|
dprintf(("PyThread_init_thread called\n"));
|
|
PyThread__init_thread();
|
|
}
|
|
|
|
/* Support for runtime thread stack size tuning.
|
|
A value of 0 means using the platform's default stack size
|
|
or the size specified by the THREAD_STACK_SIZE macro. */
|
|
static size_t _pythread_stacksize = 0;
|
|
|
|
#if defined(_POSIX_THREADS)
|
|
# define PYTHREAD_NAME "pthread"
|
|
# include "thread_pthread.h"
|
|
#elif defined(NT_THREADS)
|
|
# define PYTHREAD_NAME "nt"
|
|
# include "thread_nt.h"
|
|
#else
|
|
# error "Require native thread feature. See https://bugs.python.org/issue30832"
|
|
#endif
|
|
|
|
|
|
/* return the current thread stack size */
|
|
size_t
|
|
PyThread_get_stacksize(void)
|
|
{
|
|
return _pythread_stacksize;
|
|
}
|
|
|
|
/* Only platforms defining a THREAD_SET_STACKSIZE() macro
|
|
in thread_<platform>.h support changing the stack size.
|
|
Return 0 if stack size is valid,
|
|
-1 if stack size value is invalid,
|
|
-2 if setting stack size is not supported. */
|
|
int
|
|
PyThread_set_stacksize(size_t size)
|
|
{
|
|
#if defined(THREAD_SET_STACKSIZE)
|
|
return THREAD_SET_STACKSIZE(size);
|
|
#else
|
|
return -2;
|
|
#endif
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------------
|
|
Per-thread data ("key") support.
|
|
|
|
Use PyThread_create_key() to create a new key. This is typically shared
|
|
across threads.
|
|
|
|
Use PyThread_set_key_value(thekey, value) to associate void* value with
|
|
thekey in the current thread. Each thread has a distinct mapping of thekey
|
|
to a void* value. Caution: if the current thread already has a mapping
|
|
for thekey, value is ignored.
|
|
|
|
Use PyThread_get_key_value(thekey) to retrieve the void* value associated
|
|
with thekey in the current thread. This returns NULL if no value is
|
|
associated with thekey in the current thread.
|
|
|
|
Use PyThread_delete_key_value(thekey) to forget the current thread's associated
|
|
value for thekey. PyThread_delete_key(thekey) forgets the values associated
|
|
with thekey across *all* threads.
|
|
|
|
While some of these functions have error-return values, none set any
|
|
Python exception.
|
|
|
|
None of the functions does memory management on behalf of the void* values.
|
|
You need to allocate and deallocate them yourself. If the void* values
|
|
happen to be PyObject*, these functions don't do refcount operations on
|
|
them either.
|
|
|
|
The GIL does not need to be held when calling these functions; they supply
|
|
their own locking. This isn't true of PyThread_create_key(), though (see
|
|
next paragraph).
|
|
|
|
There's a hidden assumption that PyThread_create_key() will be called before
|
|
any of the other functions are called. There's also a hidden assumption
|
|
that calls to PyThread_create_key() are serialized externally.
|
|
------------------------------------------------------------------------ */
|
|
|
|
|
|
PyDoc_STRVAR(threadinfo__doc__,
|
|
"sys.thread_info\n\
|
|
\n\
|
|
A struct sequence holding information about the thread implementation.");
|
|
|
|
static PyStructSequence_Field threadinfo_fields[] = {
|
|
{"name", "name of the thread implementation"},
|
|
{"lock", "name of the lock implementation"},
|
|
{"version", "name and version of the thread library"},
|
|
{0}
|
|
};
|
|
|
|
static PyStructSequence_Desc threadinfo_desc = {
|
|
"sys.thread_info", /* name */
|
|
threadinfo__doc__, /* doc */
|
|
threadinfo_fields, /* fields */
|
|
3
|
|
};
|
|
|
|
static PyTypeObject ThreadInfoType;
|
|
|
|
PyObject*
|
|
PyThread_GetInfo(void)
|
|
{
|
|
PyObject *threadinfo, *value;
|
|
int pos = 0;
|
|
#if (defined(_POSIX_THREADS) && defined(HAVE_CONFSTR) \
|
|
&& defined(_CS_GNU_LIBPTHREAD_VERSION))
|
|
char buffer[255];
|
|
int len;
|
|
#endif
|
|
|
|
if (ThreadInfoType.tp_name == 0) {
|
|
if (PyStructSequence_InitType2(&ThreadInfoType, &threadinfo_desc) < 0)
|
|
return NULL;
|
|
}
|
|
|
|
threadinfo = PyStructSequence_New(&ThreadInfoType);
|
|
if (threadinfo == NULL)
|
|
return NULL;
|
|
|
|
value = PyUnicode_FromString(PYTHREAD_NAME);
|
|
if (value == NULL) {
|
|
Py_DECREF(threadinfo);
|
|
return NULL;
|
|
}
|
|
PyStructSequence_SET_ITEM(threadinfo, pos++, value);
|
|
|
|
#ifdef _POSIX_THREADS
|
|
#ifdef USE_SEMAPHORES
|
|
value = PyUnicode_FromString("semaphore");
|
|
#else
|
|
value = PyUnicode_FromString("mutex+cond");
|
|
#endif
|
|
if (value == NULL) {
|
|
Py_DECREF(threadinfo);
|
|
return NULL;
|
|
}
|
|
#else
|
|
Py_INCREF(Py_None);
|
|
value = Py_None;
|
|
#endif
|
|
PyStructSequence_SET_ITEM(threadinfo, pos++, value);
|
|
|
|
#if (defined(_POSIX_THREADS) && defined(HAVE_CONFSTR) \
|
|
&& defined(_CS_GNU_LIBPTHREAD_VERSION))
|
|
value = NULL;
|
|
len = confstr(_CS_GNU_LIBPTHREAD_VERSION, buffer, sizeof(buffer));
|
|
if (1 < len && (size_t)len < sizeof(buffer)) {
|
|
value = PyUnicode_DecodeFSDefaultAndSize(buffer, len-1);
|
|
if (value == NULL)
|
|
PyErr_Clear();
|
|
}
|
|
if (value == NULL)
|
|
#endif
|
|
{
|
|
Py_INCREF(Py_None);
|
|
value = Py_None;
|
|
}
|
|
PyStructSequence_SET_ITEM(threadinfo, pos++, value);
|
|
return threadinfo;
|
|
}
|