Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/python3.8/pythread.h @ 69:33d812a61356

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d
author jpayne
date Tue, 18 Mar 2025 17:55:14 -0400
parents
children
comparison
equal deleted inserted replaced
67:0e9998148a16 69:33d812a61356
1
2 #ifndef Py_PYTHREAD_H
3 #define Py_PYTHREAD_H
4
5 typedef void *PyThread_type_lock;
6 typedef void *PyThread_type_sema;
7
8 #ifdef __cplusplus
9 extern "C" {
10 #endif
11
12 /* Return status codes for Python lock acquisition. Chosen for maximum
13 * backwards compatibility, ie failure -> 0, success -> 1. */
14 typedef enum PyLockStatus {
15 PY_LOCK_FAILURE = 0,
16 PY_LOCK_ACQUIRED = 1,
17 PY_LOCK_INTR
18 } PyLockStatus;
19
20 #ifndef Py_LIMITED_API
21 #define PYTHREAD_INVALID_THREAD_ID ((unsigned long)-1)
22 #endif
23
24 PyAPI_FUNC(void) PyThread_init_thread(void);
25 PyAPI_FUNC(unsigned long) PyThread_start_new_thread(void (*)(void *), void *);
26 PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void);
27 PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void);
28
29 #if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(_WIN32) || defined(_AIX)
30 #define PY_HAVE_THREAD_NATIVE_ID
31 PyAPI_FUNC(unsigned long) PyThread_get_thread_native_id(void);
32 #endif
33
34 PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void);
35 PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock);
36 PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int);
37 #define WAIT_LOCK 1
38 #define NOWAIT_LOCK 0
39
40 /* PY_TIMEOUT_T is the integral type used to specify timeouts when waiting
41 on a lock (see PyThread_acquire_lock_timed() below).
42 PY_TIMEOUT_MAX is the highest usable value (in microseconds) of that
43 type, and depends on the system threading API.
44
45 NOTE: this isn't the same value as `_thread.TIMEOUT_MAX`. The _thread
46 module exposes a higher-level API, with timeouts expressed in seconds
47 and floating-point numbers allowed.
48 */
49 #define PY_TIMEOUT_T long long
50
51 #if defined(_POSIX_THREADS)
52 /* PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000),
53 convert microseconds to nanoseconds. */
54 # define PY_TIMEOUT_MAX (PY_LLONG_MAX / 1000)
55 #elif defined (NT_THREADS)
56 /* In the NT API, the timeout is a DWORD and is expressed in milliseconds */
57 # if 0xFFFFFFFFLL * 1000 < PY_LLONG_MAX
58 # define PY_TIMEOUT_MAX (0xFFFFFFFFLL * 1000)
59 # else
60 # define PY_TIMEOUT_MAX PY_LLONG_MAX
61 # endif
62 #else
63 # define PY_TIMEOUT_MAX PY_LLONG_MAX
64 #endif
65
66
67 /* If microseconds == 0, the call is non-blocking: it returns immediately
68 even when the lock can't be acquired.
69 If microseconds > 0, the call waits up to the specified duration.
70 If microseconds < 0, the call waits until success (or abnormal failure)
71
72 microseconds must be less than PY_TIMEOUT_MAX. Behaviour otherwise is
73 undefined.
74
75 If intr_flag is true and the acquire is interrupted by a signal, then the
76 call will return PY_LOCK_INTR. The caller may reattempt to acquire the
77 lock.
78 */
79 PyAPI_FUNC(PyLockStatus) PyThread_acquire_lock_timed(PyThread_type_lock,
80 PY_TIMEOUT_T microseconds,
81 int intr_flag);
82
83 PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock);
84
85 PyAPI_FUNC(size_t) PyThread_get_stacksize(void);
86 PyAPI_FUNC(int) PyThread_set_stacksize(size_t);
87
88 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
89 PyAPI_FUNC(PyObject*) PyThread_GetInfo(void);
90 #endif
91
92
93 /* Thread Local Storage (TLS) API
94 TLS API is DEPRECATED. Use Thread Specific Storage (TSS) API.
95
96 The existing TLS API has used int to represent TLS keys across all
97 platforms, but it is not POSIX-compliant. Therefore, the new TSS API uses
98 opaque data type to represent TSS keys to be compatible (see PEP 539).
99 */
100 Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_create_key(void);
101 Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key(int key);
102 Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_set_key_value(int key,
103 void *value);
104 Py_DEPRECATED(3.7) PyAPI_FUNC(void *) PyThread_get_key_value(int key);
105 Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key_value(int key);
106
107 /* Cleanup after a fork */
108 Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_ReInitTLS(void);
109
110
111 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
112 /* New in 3.7 */
113 /* Thread Specific Storage (TSS) API */
114
115 typedef struct _Py_tss_t Py_tss_t; /* opaque */
116
117 #ifndef Py_LIMITED_API
118 #if defined(_POSIX_THREADS)
119 /* Darwin needs pthread.h to know type name the pthread_key_t. */
120 # include <pthread.h>
121 # define NATIVE_TSS_KEY_T pthread_key_t
122 #elif defined(NT_THREADS)
123 /* In Windows, native TSS key type is DWORD,
124 but hardcode the unsigned long to avoid errors for include directive.
125 */
126 # define NATIVE_TSS_KEY_T unsigned long
127 #else
128 # error "Require native threads. See https://bugs.python.org/issue31370"
129 #endif
130
131 /* When Py_LIMITED_API is not defined, the type layout of Py_tss_t is
132 exposed to allow static allocation in the API clients. Even in this case,
133 you must handle TSS keys through API functions due to compatibility.
134 */
135 struct _Py_tss_t {
136 int _is_initialized;
137 NATIVE_TSS_KEY_T _key;
138 };
139
140 #undef NATIVE_TSS_KEY_T
141
142 /* When static allocation, you must initialize with Py_tss_NEEDS_INIT. */
143 #define Py_tss_NEEDS_INIT {0}
144 #endif /* !Py_LIMITED_API */
145
146 PyAPI_FUNC(Py_tss_t *) PyThread_tss_alloc(void);
147 PyAPI_FUNC(void) PyThread_tss_free(Py_tss_t *key);
148
149 /* The parameter key must not be NULL. */
150 PyAPI_FUNC(int) PyThread_tss_is_created(Py_tss_t *key);
151 PyAPI_FUNC(int) PyThread_tss_create(Py_tss_t *key);
152 PyAPI_FUNC(void) PyThread_tss_delete(Py_tss_t *key);
153 PyAPI_FUNC(int) PyThread_tss_set(Py_tss_t *key, void *value);
154 PyAPI_FUNC(void *) PyThread_tss_get(Py_tss_t *key);
155 #endif /* New in 3.7 */
156
157 #ifdef __cplusplus
158 }
159 #endif
160
161 #endif /* !Py_PYTHREAD_H */