/* * A type which wraps a semaphore * * semaphore.c * * Copyright (c) 2006-2008, R Oudkerk * Licensed to PSF under a Contributor Agreement. */ #include "multiprocessing.h" #ifdef HAVE_SYS_TIME_H # include <sys/time.h> // gettimeofday() #endif #ifdef HAVE_MP_SEMAPHORE // These match the values in Lib/multiprocessing/synchronize.py enum { … }; SemLockObject; /*[python input] class SEM_HANDLE_converter(CConverter): type = "SEM_HANDLE" format_unit = '"F_SEM_HANDLE"' [python start generated code]*/ /*[python end generated code: output=da39a3ee5e6b4b0d input=3e0ad43e482d8716]*/ /*[clinic input] module _multiprocessing class _multiprocessing.SemLock "SemLockObject *" "&_PyMp_SemLockType" [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=935fb41b7d032599]*/ #include "clinic/semaphore.c.h" #define ISMINE(o) … #ifdef MS_WINDOWS /* * Windows definitions */ #define SEM_FAILED … #define SEM_CLEAR_ERROR … #define SEM_GET_LAST_ERROR … #define SEM_CREATE … #define SEM_CLOSE … #define SEM_GETVALUE … #define SEM_UNLINK … static int _GetSemaphoreValue(HANDLE handle, long *value) { long previous; switch (WaitForSingleObjectEx(handle, 0, FALSE)) { case WAIT_OBJECT_0: if (!ReleaseSemaphore(handle, 1, &previous)) return MP_STANDARD_ERROR; *value = previous + 1; return 0; case WAIT_TIMEOUT: *value = 0; return 0; default: return MP_STANDARD_ERROR; } } /*[clinic input] @critical_section _multiprocessing.SemLock.acquire block as blocking: bool = True timeout as timeout_obj: object = None Acquire the semaphore/lock. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking, PyObject *timeout_obj) /*[clinic end generated code: output=f9998f0b6b0b0872 input=079ca779975f3ad6]*/ { double timeout; DWORD res, full_msecs, nhandles; HANDLE handles[2], sigint_event; /* calculate timeout */ if (!blocking) { full_msecs = 0; } else if (timeout_obj == Py_None) { full_msecs = INFINITE; } else { timeout = PyFloat_AsDouble(timeout_obj); if (PyErr_Occurred()) return NULL; timeout *= 1000.0; /* convert to millisecs */ if (timeout < 0.0) { timeout = 0.0; } else if (timeout >= 0.5 * INFINITE) { /* 25 days */ PyErr_SetString(PyExc_OverflowError, "timeout is too large"); return NULL; } full_msecs = (DWORD)(timeout + 0.5); } /* check whether we already own the lock */ if (self->kind == RECURSIVE_MUTEX && ISMINE(self)) { ++self->count; Py_RETURN_TRUE; } /* check whether we can acquire without releasing the GIL and blocking */ if (WaitForSingleObjectEx(self->handle, 0, FALSE) == WAIT_OBJECT_0) { self->last_tid = GetCurrentThreadId(); ++self->count; Py_RETURN_TRUE; } /* prepare list of handles */ nhandles = 0; handles[nhandles++] = self->handle; if (_PyOS_IsMainThread()) { sigint_event = _PyOS_SigintEvent(); assert(sigint_event != NULL); handles[nhandles++] = sigint_event; } else { sigint_event = NULL; } /* do the wait */ Py_BEGIN_ALLOW_THREADS if (sigint_event != NULL) ResetEvent(sigint_event); res = WaitForMultipleObjectsEx(nhandles, handles, FALSE, full_msecs, FALSE); Py_END_ALLOW_THREADS /* handle result */ switch (res) { case WAIT_TIMEOUT: Py_RETURN_FALSE; case WAIT_OBJECT_0 + 0: self->last_tid = GetCurrentThreadId(); ++self->count; Py_RETURN_TRUE; case WAIT_OBJECT_0 + 1: errno = EINTR; return PyErr_SetFromErrno(PyExc_OSError); case WAIT_FAILED: return PyErr_SetFromWindowsErr(0); default: PyErr_Format(PyExc_RuntimeError, "WaitForSingleObject() or " "WaitForMultipleObjects() gave unrecognized " "value %u", res); return NULL; } } /*[clinic input] @critical_section _multiprocessing.SemLock.release Release the semaphore/lock. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock_release_impl(SemLockObject *self) /*[clinic end generated code: output=b22f53ba96b0d1db input=9bd62d3645e7a531]*/ { if (self->kind == RECURSIVE_MUTEX) { if (!ISMINE(self)) { PyErr_SetString(PyExc_AssertionError, "attempt to " "release recursive lock not owned " "by thread"); return NULL; } if (self->count > 1) { --self->count; Py_RETURN_NONE; } assert(self->count == 1); } if (!ReleaseSemaphore(self->handle, 1, NULL)) { if (GetLastError() == ERROR_TOO_MANY_POSTS) { PyErr_SetString(PyExc_ValueError, "semaphore or lock " "released too many times"); return NULL; } else { return PyErr_SetFromWindowsErr(0); } } --self->count; Py_RETURN_NONE; } #else /* !MS_WINDOWS */ /* * Unix definitions */ #define SEM_CLEAR_ERROR() … #define SEM_GET_LAST_ERROR() … #define SEM_CREATE(name, val, max) … #define SEM_CLOSE(sem) … #define SEM_GETVALUE(sem, pval) … #define SEM_UNLINK(name) … /* OS X 10.4 defines SEM_FAILED as -1 instead of (sem_t *)-1; this gives compiler warnings, and (potentially) undefined behaviour. */ #ifdef __APPLE__ # undef SEM_FAILED #define SEM_FAILED … #endif #ifndef HAVE_SEM_UNLINK #define sem_unlink … #endif #ifndef HAVE_SEM_TIMEDWAIT #define sem_timedwait … static int sem_timedwait_save(sem_t *sem, struct timespec *deadline, PyThreadState *_save) { int res; unsigned long delay, difference; struct timeval now, tvdeadline, tvdelay; errno = 0; tvdeadline.tv_sec = deadline->tv_sec; tvdeadline.tv_usec = deadline->tv_nsec / 1000; for (delay = 0 ; ; delay += 1000) { /* poll */ if (sem_trywait(sem) == 0) return 0; else if (errno != EAGAIN) return MP_STANDARD_ERROR; /* get current time */ if (gettimeofday(&now, NULL) < 0) return MP_STANDARD_ERROR; /* check for timeout */ if (tvdeadline.tv_sec < now.tv_sec || (tvdeadline.tv_sec == now.tv_sec && tvdeadline.tv_usec <= now.tv_usec)) { errno = ETIMEDOUT; return MP_STANDARD_ERROR; } /* calculate how much time is left */ difference = (tvdeadline.tv_sec - now.tv_sec) * 1000000 + (tvdeadline.tv_usec - now.tv_usec); /* check delay not too long -- maximum is 20 msecs */ if (delay > 20000) delay = 20000; if (delay > difference) delay = difference; /* sleep */ tvdelay.tv_sec = delay / 1000000; tvdelay.tv_usec = delay % 1000000; if (select(0, NULL, NULL, NULL, &tvdelay) < 0) return MP_STANDARD_ERROR; /* check for signals */ Py_BLOCK_THREADS res = PyErr_CheckSignals(); Py_UNBLOCK_THREADS if (res) { errno = EINTR; return MP_EXCEPTION_HAS_BEEN_SET; } } } #endif /* !HAVE_SEM_TIMEDWAIT */ /*[clinic input] @critical_section _multiprocessing.SemLock.acquire block as blocking: bool = True timeout as timeout_obj: object = None Acquire the semaphore/lock. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking, PyObject *timeout_obj) /*[clinic end generated code: output=f9998f0b6b0b0872 input=079ca779975f3ad6]*/ { … } /*[clinic input] @critical_section _multiprocessing.SemLock.release Release the semaphore/lock. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock_release_impl(SemLockObject *self) /*[clinic end generated code: output=b22f53ba96b0d1db input=9bd62d3645e7a531]*/ { … } #endif /* !MS_WINDOWS */ /* * All platforms */ static PyObject * newsemlockobject(PyTypeObject *type, SEM_HANDLE handle, int kind, int maxvalue, char *name) { … } /*[clinic input] @classmethod _multiprocessing.SemLock.__new__ kind: int value: int maxvalue: int name: str unlink: bool [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock_impl(PyTypeObject *type, int kind, int value, int maxvalue, const char *name, int unlink) /*[clinic end generated code: output=30727e38f5f7577a input=fdaeb69814471c5b]*/ { … } /*[clinic input] @classmethod _multiprocessing.SemLock._rebuild handle: SEM_HANDLE kind: int maxvalue: int name: str(accept={str, NoneType}) / [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock__rebuild_impl(PyTypeObject *type, SEM_HANDLE handle, int kind, int maxvalue, const char *name) /*[clinic end generated code: output=2aaee14f063f3bd9 input=f7040492ac6d9962]*/ { … } static void semlock_dealloc(SemLockObject* self) { … } /*[clinic input] @critical_section _multiprocessing.SemLock._count Num of `acquire()`s minus num of `release()`s for this process. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock__count_impl(SemLockObject *self) /*[clinic end generated code: output=5ba8213900e517bb input=9fa6e0b321b16935]*/ { … } /*[clinic input] _multiprocessing.SemLock._is_mine Whether the lock is owned by this thread. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock__is_mine_impl(SemLockObject *self) /*[clinic end generated code: output=92dc98863f4303be input=a96664cb2f0093ba]*/ { … } /*[clinic input] _multiprocessing.SemLock._get_value Get the value of the semaphore. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock__get_value_impl(SemLockObject *self) /*[clinic end generated code: output=64bc1b89bda05e36 input=cb10f9a769836203]*/ { … } /*[clinic input] _multiprocessing.SemLock._is_zero Return whether semaphore has value zero. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock__is_zero_impl(SemLockObject *self) /*[clinic end generated code: output=815d4c878c806ed7 input=294a446418d31347]*/ { … } /*[clinic input] _multiprocessing.SemLock._after_fork Rezero the net acquisition count after fork(). [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock__after_fork_impl(SemLockObject *self) /*[clinic end generated code: output=718bb27914c6a6c1 input=190991008a76621e]*/ { … } /*[clinic input] @critical_section _multiprocessing.SemLock.__enter__ Enter the semaphore/lock. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock___enter___impl(SemLockObject *self) /*[clinic end generated code: output=beeb2f07c858511f input=d35c9860992ee790]*/ { … } /*[clinic input] @critical_section _multiprocessing.SemLock.__exit__ exc_type: object = None exc_value: object = None exc_tb: object = None / Exit the semaphore/lock. [clinic start generated code]*/ static PyObject * _multiprocessing_SemLock___exit___impl(SemLockObject *self, PyObject *exc_type, PyObject *exc_value, PyObject *exc_tb) /*[clinic end generated code: output=3b37c1a9f8b91a03 input=1610c8cc3e0e337e]*/ { … } static int semlock_traverse(SemLockObject *s, visitproc visit, void *arg) { … } /* * Semaphore methods */ static PyMethodDef semlock_methods[] = …; /* * Member table */ static PyMemberDef semlock_members[] = …; /* * Semaphore type */ static PyType_Slot _PyMp_SemLockType_slots[] = …; PyType_Spec _PyMp_SemLockType_spec = …; /* * Function to unlink semaphore names */ PyObject * _PyMp_sem_unlink(const char *name) { … } #endif // HAVE_MP_SEMAPHORE
Codebase Browser
cpython