cpython/Python/condvar.h at main · python/cpython · GitHub

History

315 lines (274 loc) · 8.56 KB

Raw

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

310

311

312

313

314

315

* 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_pythread.h" // _POSIX_THREADS

#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_timeout;

_PyThread_cond_after(us, &abs_timeout);

int ret = pthread_cond_timedwait(cond, mut, &abs_timeout);

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;

}

/* return 0 for success, 1 on timeout, -1 on error */

Py_LOCAL_INLINE(int)

PyCOND_TIMEDWAIT(PyCOND_T *cv, PyMUTEX_T *cs, long long us)

{

BOOL success = SleepConditionVariableSRW(cv, cs, (DWORD)(us/1000), 0);

if (!success) {

if (GetLastError() == ERROR_TIMEOUT) {

return 1;

}

return -1;

}

return 0;

}

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_ */

cpython/Python/condvar.h at main · python/cpython · GitHub

Uh oh!

Uh oh!

cpython/Python/condvar.h at main · python/cpython · GitHub

Uh oh!

Uh oh!

Expand file tree

Breadcrumbs

condvar.h

Latest commit

History

Breadcrumbs

condvar.h

File metadata and controls