FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
cpython/Python/condvar.h at 3.11 · python/cpython · GitHub
python
cpython
Repository navigation
Code
Issues
5k+
(5k+)
Pull requests
2.7k
(2.7k)
Actions
Projects
Security and quality
Insights
Expand file tree
Breadcrumbs
cpython
/
Python
/
condvar.h
Copy path
More file actions
More file actions
Latest commit
History
History
History
309 lines (269 loc) · 8.44 KB
Breadcrumbs
cpython
/
Python
/
condvar.h
Copy path
File metadata and controls
309 lines (269 loc) · 8.44 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
/*
* Portable condition variable support for windows and pthreads.
* Everything is inline, this header can be included where needed.
*
* APIs generally return 0 on success and non-zero on error,
* and the caller needs to use its platform's error mechanism to
* discover the error (errno, or GetLastError())
*
* Note that some implementations cannot distinguish between a
* condition variable wait time-out and successful wait. Most often
* the difference is moot anyway since the wait condition must be
* re-checked.
* PyCOND_TIMEDWAIT, in addition to returning negative on error,
* thus returns 0 on regular success, 1 on timeout
* or 2 if it can't tell.
*
* There are at least two caveats with using these condition variables,
* due to the fact that they may be emulated with Semaphores on
* Windows:
* 1) While PyCOND_SIGNAL() will wake up at least one thread, we
* cannot currently guarantee that it will be one of the threads
* already waiting in a PyCOND_WAIT() call. It _could_ cause
* the wakeup of a subsequent thread to try a PyCOND_WAIT(),
* including the thread doing the PyCOND_SIGNAL() itself.
* The same applies to PyCOND_BROADCAST(), if N threads are waiting
* then at least N threads will be woken up, but not necessarily
* those already waiting.
* For this reason, don't make the scheduling assumption that a
* specific other thread will get the wakeup signal
* 2) The _mutex_ must be held when calling PyCOND_SIGNAL() and
* PyCOND_BROADCAST().
* While e.g. the posix standard strongly recommends that the mutex
* associated with the condition variable is held when a
* pthread_cond_signal() call is made, this is not a hard requirement,
* although scheduling will not be "reliable" if it isn't. Here
* the mutex is used for internal synchronization of the emulated
* Condition Variable.
*/
#ifndef
_CONDVAR_IMPL_H_
#define
_CONDVAR_IMPL_H_
#include
"Python.h"
#include
"pycore_condvar.h"
#ifdef
_POSIX_THREADS
/*
* POSIX support
*/
/* These private functions are implemented in Python/thread_pthread.h */
int
_PyThread_cond_init
(
PyCOND_T
*
cond
);
void
_PyThread_cond_after
(
long long
us
,
struct
timespec
*
abs
);
/* The following functions return 0 on success, nonzero on error */
#define
PyMUTEX_INIT
(
mut
) pthread_mutex_init((mut), NULL)
#define
PyMUTEX_FINI
(
mut
) pthread_mutex_destroy(mut)
#define
PyMUTEX_LOCK
(
mut
) pthread_mutex_lock(mut)
#define
PyMUTEX_UNLOCK
(
mut
) pthread_mutex_unlock(mut)
#define
PyCOND_INIT
(
cond
) _PyThread_cond_init(cond)
#define
PyCOND_FINI
(
cond
) pthread_cond_destroy(cond)
#define
PyCOND_SIGNAL
(
cond
) pthread_cond_signal(cond)
#define
PyCOND_BROADCAST
(
cond
) pthread_cond_broadcast(cond)
#define
PyCOND_WAIT
(
cond
,
mut
) pthread_cond_wait((cond), (mut))
/* return 0 for success, 1 on timeout, -1 on error */
Py_LOCAL_INLINE
(
int
)
PyCOND_TIMEDWAIT
(
PyCOND_T
*
cond
,
PyMUTEX_T
*
mut
,
long long
us
)
{
struct
timespec
abs
;
_PyThread_cond_after
(
us
,
&
abs
);
int
ret
=
pthread_cond_timedwait
(
cond
,
mut
,
&
abs
);
if
(
ret
==
ETIMEDOUT
) {
return
1
;
}
if
(
ret
) {
return
-1
;
}
return
0
;
}
#elif
defined(
NT_THREADS
)
/*
* Windows (XP, 2003 server and later, as well as (hopefully) CE) support
*
* Emulated condition variables ones that work with XP and later, plus
* example native support on VISTA and onwards.
*/
#if
_PY_EMULATED_WIN_CV
/* The mutex is a CriticalSection object and
The condition variables is emulated with the help of a semaphore.
This implementation still has the problem that the threads woken
with a "signal" aren't necessarily those that are already
waiting. It corresponds to listing 2 in:
http://birrell.org/andrew/papers/ImplementingCVs.pdf
Generic emulations of the pthread_cond_* API using
earlier Win32 functions can be found on the web.
The following read can be give background information to these issues,
but the implementations are all broken in some way.
http://www.cse.wustl.edu/~schmidt/win32-cv-1.html
*/
Py_LOCAL_INLINE
(
int
)
PyMUTEX_INIT
(
PyMUTEX_T
*
cs
)
{
InitializeCriticalSection
(
cs
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyMUTEX_FINI
(
PyMUTEX_T
*
cs
)
{
DeleteCriticalSection
(
cs
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyMUTEX_LOCK
(
PyMUTEX_T
*
cs
)
{
EnterCriticalSection
(
cs
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyMUTEX_UNLOCK
(
PyMUTEX_T
*
cs
)
{
LeaveCriticalSection
(
cs
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_INIT
(
PyCOND_T
*
cv
)
{
/* 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.
*/
cv
->
sem
=
CreateSemaphore
(
NULL
,
0
,
100000
,
NULL
);
if
(
cv
->
sem
==
NULL
)
return
-1
;
cv
->
waiting
=
0
;
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_FINI
(
PyCOND_T
*
cv
)
{
return
CloseHandle
(
cv
->
sem
) ?
0
:
-1
;
}
/* this implementation can detect a timeout. Returns 1 on timeout,
* 0 otherwise (and -1 on error)
*/
Py_LOCAL_INLINE
(
int
)
_PyCOND_WAIT_MS
(
PyCOND_T
*
cv
,
PyMUTEX_T
*
cs
,
DWORD
ms
)
{
DWORD
wait
;
cv
->
waiting
++
;
PyMUTEX_UNLOCK
(
cs
);
/* "lost wakeup bug" would occur if the caller were interrupted here,
* but we are safe because we are using a semaphore which has an internal
* count.
*/
wait
=
WaitForSingleObjectEx
(
cv
->
sem
,
ms
, FALSE);
PyMUTEX_LOCK
(
cs
);
if
(
wait
!=
WAIT_OBJECT_0
)
--
cv
->
waiting
;
/* Here we have a benign race condition with PyCOND_SIGNAL.
* When failure occurs or timeout, it is possible that
* PyCOND_SIGNAL also decrements this value
* and signals releases the mutex. This is benign because it
* just means an extra spurious wakeup for a waiting thread.
* ('waiting' corresponds to the semaphore's "negative" count and
* we may end up with e.g. (waiting == -1 && sem.count == 1). When
* a new thread comes along, it will pass right through, having
* adjusted it to (waiting == 0 && sem.count == 0).
*/
if
(
wait
==
WAIT_FAILED
)
return
-1
;
/* return 0 on success, 1 on timeout */
return
wait
!=
WAIT_OBJECT_0
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_WAIT
(
PyCOND_T
*
cv
,
PyMUTEX_T
*
cs
)
{
int
result
=
_PyCOND_WAIT_MS
(
cv
,
cs
,
INFINITE
);
return
result
>=
0
?
0
:
result
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_TIMEDWAIT
(
PyCOND_T
*
cv
,
PyMUTEX_T
*
cs
,
long long
us
)
{
return
_PyCOND_WAIT_MS
(
cv
,
cs
, (
DWORD
)(
us
/
1000
));
}
Py_LOCAL_INLINE
(
int
)
PyCOND_SIGNAL
(
PyCOND_T
*
cv
)
{
/* this test allows PyCOND_SIGNAL to be a no-op unless required
* to wake someone up, thus preventing an unbounded increase of
* the semaphore's internal counter.
*/
if
(
cv
->
waiting
>
0
) {
/* notifying thread decreases the cv->waiting count so that
* a delay between notify and actual wakeup of the target thread
* doesn't cause a number of extra ReleaseSemaphore calls.
*/
cv
->
waiting
--
;
return
ReleaseSemaphore
(
cv
->
sem
,
1
,
NULL
) ?
0
:
-1
;
}
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_BROADCAST
(
PyCOND_T
*
cv
)
{
int
waiting
=
cv
->
waiting
;
if
(
waiting
>
0
) {
cv
->
waiting
=
0
;
return
ReleaseSemaphore
(
cv
->
sem
,
waiting
,
NULL
) ?
0
:
-1
;
}
return
0
;
}
#else
/* !_PY_EMULATED_WIN_CV */
Py_LOCAL_INLINE
(
int
)
PyMUTEX_INIT
(
PyMUTEX_T
*
cs
)
{
InitializeSRWLock
(
cs
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyMUTEX_FINI
(
PyMUTEX_T
*
cs
)
{
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyMUTEX_LOCK
(
PyMUTEX_T
*
cs
)
{
AcquireSRWLockExclusive
(
cs
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyMUTEX_UNLOCK
(
PyMUTEX_T
*
cs
)
{
ReleaseSRWLockExclusive
(
cs
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_INIT
(
PyCOND_T
*
cv
)
{
InitializeConditionVariable
(
cv
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_FINI
(
PyCOND_T
*
cv
)
{
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_WAIT
(
PyCOND_T
*
cv
,
PyMUTEX_T
*
cs
)
{
return
SleepConditionVariableSRW
(
cv
,
cs
,
INFINITE
,
0
) ?
0
:
-1
;
}
/* This implementation makes no distinction about timeouts. Signal
* 2 to indicate that we don't know.
*/
Py_LOCAL_INLINE
(
int
)
PyCOND_TIMEDWAIT
(
PyCOND_T
*
cv
,
PyMUTEX_T
*
cs
,
long long
us
)
{
return
SleepConditionVariableSRW
(
cv
,
cs
, (
DWORD
)(
us
/
1000
),
0
) ?
2
:
-1
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_SIGNAL
(
PyCOND_T
*
cv
)
{
WakeConditionVariable
(
cv
);
return
0
;
}
Py_LOCAL_INLINE
(
int
)
PyCOND_BROADCAST
(
PyCOND_T
*
cv
)
{
WakeAllConditionVariable
(
cv
);
return
0
;
}
#endif
/* _PY_EMULATED_WIN_CV */
#endif
/* _POSIX_THREADS, NT_THREADS */
#endif
/* _CONDVAR_IMPL_H_ */
Back
|
FazBrowse Home
|
New Git URL