bpo-20175: Convert Modules/_multiprocessing to the Argument Clinic (GH-14245)
This commit is contained in:
Zackery Spytz
GitHub
parent
b7047e59a4
commit
545b54d2ab
|
|
@ -0,0 +1,151 @@
|
|||
/*[clinic input]
|
||||
preserve
|
||||
[clinic start generated code]*/
|
||||
|
||||
#if defined(MS_WINDOWS)
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_closesocket__doc__,
|
||||
"closesocket($module, handle, /)\n"
|
||||
"--\n"
|
||||
"\n");
|
||||
|
||||
#define _MULTIPROCESSING_CLOSESOCKET_METHODDEF \
|
||||
{"closesocket", (PyCFunction)_multiprocessing_closesocket, METH_O, _multiprocessing_closesocket__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_closesocket_impl(PyObject *module, HANDLE handle);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_closesocket(PyObject *module, PyObject *arg)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
|
||||
if (!PyArg_Parse(arg, ""F_HANDLE":closesocket", &handle)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _multiprocessing_closesocket_impl(module, handle);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
#endif /* defined(MS_WINDOWS) */
|
||||
|
||||
#if defined(MS_WINDOWS)
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_recv__doc__,
|
||||
"recv($module, handle, size, /)\n"
|
||||
"--\n"
|
||||
"\n");
|
||||
|
||||
#define _MULTIPROCESSING_RECV_METHODDEF \
|
||||
{"recv", (PyCFunction)(void(*)(void))_multiprocessing_recv, METH_FASTCALL, _multiprocessing_recv__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_recv_impl(PyObject *module, HANDLE handle, int size);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_recv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
int size;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"i:recv",
|
||||
&handle, &size)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _multiprocessing_recv_impl(module, handle, size);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
#endif /* defined(MS_WINDOWS) */
|
||||
|
||||
#if defined(MS_WINDOWS)
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_send__doc__,
|
||||
"send($module, handle, buf, /)\n"
|
||||
"--\n"
|
||||
"\n");
|
||||
|
||||
#define _MULTIPROCESSING_SEND_METHODDEF \
|
||||
{"send", (PyCFunction)(void(*)(void))_multiprocessing_send, METH_FASTCALL, _multiprocessing_send__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_send_impl(PyObject *module, HANDLE handle, Py_buffer *buf);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_send(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
Py_buffer buf = {NULL, NULL};
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*:send",
|
||||
&handle, &buf)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _multiprocessing_send_impl(module, handle, &buf);
|
||||
|
||||
exit:
|
||||
/* Cleanup for buf */
|
||||
if (buf.obj) {
|
||||
PyBuffer_Release(&buf);
|
||||
}
|
||||
|
||||
return return_value;
|
||||
}
|
||||
|
||||
#endif /* defined(MS_WINDOWS) */
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_sem_unlink__doc__,
|
||||
"sem_unlink($module, name, /)\n"
|
||||
"--\n"
|
||||
"\n");
|
||||
|
||||
#define _MULTIPROCESSING_SEM_UNLINK_METHODDEF \
|
||||
{"sem_unlink", (PyCFunction)_multiprocessing_sem_unlink, METH_O, _multiprocessing_sem_unlink__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_sem_unlink_impl(PyObject *module, const char *name);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_sem_unlink(PyObject *module, PyObject *arg)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
const char *name;
|
||||
|
||||
if (!PyUnicode_Check(arg)) {
|
||||
_PyArg_BadArgument("sem_unlink", "argument", "str", arg);
|
||||
goto exit;
|
||||
}
|
||||
Py_ssize_t name_length;
|
||||
name = PyUnicode_AsUTF8AndSize(arg, &name_length);
|
||||
if (name == NULL) {
|
||||
goto exit;
|
||||
}
|
||||
if (strlen(name) != (size_t)name_length) {
|
||||
PyErr_SetString(PyExc_ValueError, "embedded null character");
|
||||
goto exit;
|
||||
}
|
||||
return_value = _multiprocessing_sem_unlink_impl(module, name);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
#ifndef _MULTIPROCESSING_CLOSESOCKET_METHODDEF
|
||||
#define _MULTIPROCESSING_CLOSESOCKET_METHODDEF
|
||||
#endif /* !defined(_MULTIPROCESSING_CLOSESOCKET_METHODDEF) */
|
||||
|
||||
#ifndef _MULTIPROCESSING_RECV_METHODDEF
|
||||
#define _MULTIPROCESSING_RECV_METHODDEF
|
||||
#endif /* !defined(_MULTIPROCESSING_RECV_METHODDEF) */
|
||||
|
||||
#ifndef _MULTIPROCESSING_SEND_METHODDEF
|
||||
#define _MULTIPROCESSING_SEND_METHODDEF
|
||||
#endif /* !defined(_MULTIPROCESSING_SEND_METHODDEF) */
|
||||
/*[clinic end generated code: output=418191c446cd5751 input=a9049054013a1b77]*/
|
||||
|
|
@ -0,0 +1,402 @@
|
|||
/*[clinic input]
|
||||
preserve
|
||||
[clinic start generated code]*/
|
||||
|
||||
#if defined(MS_WINDOWS)
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock_acquire__doc__,
|
||||
"acquire($self, /, block=True, timeout=None)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Acquire the semaphore/lock.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF \
|
||||
{"acquire", (PyCFunction)(void(*)(void))_multiprocessing_SemLock_acquire, METH_FASTCALL|METH_KEYWORDS, _multiprocessing_SemLock_acquire__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
|
||||
PyObject *timeout_obj);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_acquire(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
static const char * const _keywords[] = {"block", "timeout", NULL};
|
||||
static _PyArg_Parser _parser = {NULL, _keywords, "acquire", 0};
|
||||
PyObject *argsbuf[2];
|
||||
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
|
||||
int blocking = 1;
|
||||
PyObject *timeout_obj = Py_None;
|
||||
|
||||
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
|
||||
if (!args) {
|
||||
goto exit;
|
||||
}
|
||||
if (!noptargs) {
|
||||
goto skip_optional_pos;
|
||||
}
|
||||
if (args[0]) {
|
||||
blocking = _PyLong_AsInt(args[0]);
|
||||
if (blocking == -1 && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
}
|
||||
if (!--noptargs) {
|
||||
goto skip_optional_pos;
|
||||
}
|
||||
}
|
||||
timeout_obj = args[1];
|
||||
skip_optional_pos:
|
||||
return_value = _multiprocessing_SemLock_acquire_impl(self, blocking, timeout_obj);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
#endif /* defined(MS_WINDOWS) */
|
||||
|
||||
#if defined(MS_WINDOWS)
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock_release__doc__,
|
||||
"release($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Release the semaphore/lock.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF \
|
||||
{"release", (PyCFunction)_multiprocessing_SemLock_release, METH_NOARGS, _multiprocessing_SemLock_release__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_release_impl(SemLockObject *self);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_release(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _multiprocessing_SemLock_release_impl(self);
|
||||
}
|
||||
|
||||
#endif /* defined(MS_WINDOWS) */
|
||||
|
||||
#if !defined(MS_WINDOWS)
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock_acquire__doc__,
|
||||
"acquire($self, /, block=True, timeout=None)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Acquire the semaphore/lock.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF \
|
||||
{"acquire", (PyCFunction)(void(*)(void))_multiprocessing_SemLock_acquire, METH_FASTCALL|METH_KEYWORDS, _multiprocessing_SemLock_acquire__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
|
||||
PyObject *timeout_obj);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_acquire(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
static const char * const _keywords[] = {"block", "timeout", NULL};
|
||||
static _PyArg_Parser _parser = {NULL, _keywords, "acquire", 0};
|
||||
PyObject *argsbuf[2];
|
||||
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
|
||||
int blocking = 1;
|
||||
PyObject *timeout_obj = Py_None;
|
||||
|
||||
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
|
||||
if (!args) {
|
||||
goto exit;
|
||||
}
|
||||
if (!noptargs) {
|
||||
goto skip_optional_pos;
|
||||
}
|
||||
if (args[0]) {
|
||||
blocking = _PyLong_AsInt(args[0]);
|
||||
if (blocking == -1 && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
}
|
||||
if (!--noptargs) {
|
||||
goto skip_optional_pos;
|
||||
}
|
||||
}
|
||||
timeout_obj = args[1];
|
||||
skip_optional_pos:
|
||||
return_value = _multiprocessing_SemLock_acquire_impl(self, blocking, timeout_obj);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
#endif /* !defined(MS_WINDOWS) */
|
||||
|
||||
#if !defined(MS_WINDOWS)
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock_release__doc__,
|
||||
"release($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Release the semaphore/lock.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF \
|
||||
{"release", (PyCFunction)_multiprocessing_SemLock_release, METH_NOARGS, _multiprocessing_SemLock_release__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_release_impl(SemLockObject *self);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_release(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _multiprocessing_SemLock_release_impl(self);
|
||||
}
|
||||
|
||||
#endif /* !defined(MS_WINDOWS) */
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock_impl(PyTypeObject *type, int kind, int value,
|
||||
int maxvalue, const char *name, int unlink);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock(PyTypeObject *type, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
static const char * const _keywords[] = {"kind", "value", "maxvalue", "name", "unlink", NULL};
|
||||
static _PyArg_Parser _parser = {NULL, _keywords, "SemLock", 0};
|
||||
PyObject *argsbuf[5];
|
||||
PyObject * const *fastargs;
|
||||
Py_ssize_t nargs = PyTuple_GET_SIZE(args);
|
||||
int kind;
|
||||
int value;
|
||||
int maxvalue;
|
||||
const char *name;
|
||||
int unlink;
|
||||
|
||||
fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 5, 5, 0, argsbuf);
|
||||
if (!fastargs) {
|
||||
goto exit;
|
||||
}
|
||||
kind = _PyLong_AsInt(fastargs[0]);
|
||||
if (kind == -1 && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
}
|
||||
value = _PyLong_AsInt(fastargs[1]);
|
||||
if (value == -1 && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
}
|
||||
maxvalue = _PyLong_AsInt(fastargs[2]);
|
||||
if (maxvalue == -1 && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
}
|
||||
if (!PyUnicode_Check(fastargs[3])) {
|
||||
_PyArg_BadArgument("SemLock", "argument 'name'", "str", fastargs[3]);
|
||||
goto exit;
|
||||
}
|
||||
Py_ssize_t name_length;
|
||||
name = PyUnicode_AsUTF8AndSize(fastargs[3], &name_length);
|
||||
if (name == NULL) {
|
||||
goto exit;
|
||||
}
|
||||
if (strlen(name) != (size_t)name_length) {
|
||||
PyErr_SetString(PyExc_ValueError, "embedded null character");
|
||||
goto exit;
|
||||
}
|
||||
unlink = _PyLong_AsInt(fastargs[4]);
|
||||
if (unlink == -1 && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _multiprocessing_SemLock_impl(type, kind, value, maxvalue, name, unlink);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock__rebuild__doc__,
|
||||
"_rebuild($type, handle, kind, maxvalue, name, /)\n"
|
||||
"--\n"
|
||||
"\n");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF \
|
||||
{"_rebuild", (PyCFunction)(void(*)(void))_multiprocessing_SemLock__rebuild, METH_FASTCALL|METH_CLASS, _multiprocessing_SemLock__rebuild__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__rebuild_impl(PyTypeObject *type, SEM_HANDLE handle,
|
||||
int kind, int maxvalue,
|
||||
const char *name);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__rebuild(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
SEM_HANDLE handle;
|
||||
int kind;
|
||||
int maxvalue;
|
||||
const char *name;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_SEM_HANDLE"iiz:_rebuild",
|
||||
&handle, &kind, &maxvalue, &name)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _multiprocessing_SemLock__rebuild_impl(type, handle, kind, maxvalue, name);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock__count__doc__,
|
||||
"_count($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Num of `acquire()`s minus num of `release()`s for this process.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF \
|
||||
{"_count", (PyCFunction)_multiprocessing_SemLock__count, METH_NOARGS, _multiprocessing_SemLock__count__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__count_impl(SemLockObject *self);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__count(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _multiprocessing_SemLock__count_impl(self);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock__is_mine__doc__,
|
||||
"_is_mine($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Whether the lock is owned by this thread.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF \
|
||||
{"_is_mine", (PyCFunction)_multiprocessing_SemLock__is_mine, METH_NOARGS, _multiprocessing_SemLock__is_mine__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__is_mine_impl(SemLockObject *self);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__is_mine(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _multiprocessing_SemLock__is_mine_impl(self);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock__get_value__doc__,
|
||||
"_get_value($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Get the value of the semaphore.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF \
|
||||
{"_get_value", (PyCFunction)_multiprocessing_SemLock__get_value, METH_NOARGS, _multiprocessing_SemLock__get_value__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__get_value_impl(SemLockObject *self);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__get_value(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _multiprocessing_SemLock__get_value_impl(self);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock__is_zero__doc__,
|
||||
"_is_zero($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Return whether semaphore has value zero.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF \
|
||||
{"_is_zero", (PyCFunction)_multiprocessing_SemLock__is_zero, METH_NOARGS, _multiprocessing_SemLock__is_zero__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__is_zero_impl(SemLockObject *self);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__is_zero(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _multiprocessing_SemLock__is_zero_impl(self);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock__after_fork__doc__,
|
||||
"_after_fork($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Rezero the net acquisition count after fork().");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF \
|
||||
{"_after_fork", (PyCFunction)_multiprocessing_SemLock__after_fork, METH_NOARGS, _multiprocessing_SemLock__after_fork__doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__after_fork_impl(SemLockObject *self);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock__after_fork(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _multiprocessing_SemLock__after_fork_impl(self);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock___enter____doc__,
|
||||
"__enter__($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Enter the semaphore/lock.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF \
|
||||
{"__enter__", (PyCFunction)_multiprocessing_SemLock___enter__, METH_NOARGS, _multiprocessing_SemLock___enter____doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock___enter___impl(SemLockObject *self);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock___enter__(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _multiprocessing_SemLock___enter___impl(self);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_multiprocessing_SemLock___exit____doc__,
|
||||
"__exit__($self, exc_type=None, exc_value=None, exc_tb=None, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Exit the semaphore/lock.");
|
||||
|
||||
#define _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF \
|
||||
{"__exit__", (PyCFunction)(void(*)(void))_multiprocessing_SemLock___exit__, METH_FASTCALL, _multiprocessing_SemLock___exit____doc__},
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock___exit___impl(SemLockObject *self,
|
||||
PyObject *exc_type,
|
||||
PyObject *exc_value, PyObject *exc_tb);
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_SemLock___exit__(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyObject *exc_type = Py_None;
|
||||
PyObject *exc_value = Py_None;
|
||||
PyObject *exc_tb = Py_None;
|
||||
|
||||
if (!_PyArg_CheckPositional("__exit__", nargs, 0, 3)) {
|
||||
goto exit;
|
||||
}
|
||||
if (nargs < 1) {
|
||||
goto skip_optional;
|
||||
}
|
||||
exc_type = args[0];
|
||||
if (nargs < 2) {
|
||||
goto skip_optional;
|
||||
}
|
||||
exc_value = args[1];
|
||||
if (nargs < 3) {
|
||||
goto skip_optional;
|
||||
}
|
||||
exc_tb = args[2];
|
||||
skip_optional:
|
||||
return_value = _multiprocessing_SemLock___exit___impl(self, exc_type, exc_value, exc_tb);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
#ifndef _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
|
||||
#define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
|
||||
#endif /* !defined(_MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF) */
|
||||
|
||||
#ifndef _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
|
||||
#define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
|
||||
#endif /* !defined(_MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF) */
|
||||
/*[clinic end generated code: output=e7fd938150601fe5 input=a9049054013a1b77]*/
|
||||
|
|
@ -9,6 +9,20 @@
|
|||
|
||||
#include "multiprocessing.h"
|
||||
|
||||
/*[python input]
|
||||
class HANDLE_converter(CConverter):
|
||||
type = "HANDLE"
|
||||
format_unit = '"F_HANDLE"'
|
||||
|
||||
[python start generated code]*/
|
||||
/*[python end generated code: output=da39a3ee5e6b4b0d input=9fad6080b79ace91]*/
|
||||
|
||||
/*[clinic input]
|
||||
module _multiprocessing
|
||||
[clinic start generated code]*/
|
||||
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=01e0745f380ac6e3]*/
|
||||
|
||||
#include "clinic/multiprocessing.c.h"
|
||||
|
||||
/*
|
||||
* Function which raises exceptions based on error codes
|
||||
|
|
@ -50,14 +64,19 @@ _PyMp_SetError(PyObject *Type, int num)
|
|||
}
|
||||
|
||||
#ifdef MS_WINDOWS
|
||||
static PyObject *
|
||||
multiprocessing_closesocket(PyObject *self, PyObject *args)
|
||||
{
|
||||
HANDLE handle;
|
||||
int ret;
|
||||
/*[clinic input]
|
||||
_multiprocessing.closesocket
|
||||
|
||||
if (!PyArg_ParseTuple(args, F_HANDLE ":closesocket" , &handle))
|
||||
return NULL;
|
||||
handle: HANDLE
|
||||
/
|
||||
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_closesocket_impl(PyObject *module, HANDLE handle)
|
||||
/*[clinic end generated code: output=214f359f900966f4 input=8a20706dd386c6cc]*/
|
||||
{
|
||||
int ret;
|
||||
|
||||
Py_BEGIN_ALLOW_THREADS
|
||||
ret = closesocket((SOCKET) handle);
|
||||
|
|
@ -68,15 +87,21 @@ multiprocessing_closesocket(PyObject *self, PyObject *args)
|
|||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
multiprocessing_recv(PyObject *self, PyObject *args)
|
||||
{
|
||||
HANDLE handle;
|
||||
int size, nread;
|
||||
PyObject *buf;
|
||||
/*[clinic input]
|
||||
_multiprocessing.recv
|
||||
|
||||
if (!PyArg_ParseTuple(args, F_HANDLE "i:recv" , &handle, &size))
|
||||
return NULL;
|
||||
handle: HANDLE
|
||||
size: int
|
||||
/
|
||||
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_recv_impl(PyObject *module, HANDLE handle, int size)
|
||||
/*[clinic end generated code: output=92322781ba9ff598 input=6a5b0834372cee5b]*/
|
||||
{
|
||||
int nread;
|
||||
PyObject *buf;
|
||||
|
||||
buf = PyBytes_FromStringAndSize(NULL, size);
|
||||
if (!buf)
|
||||
|
|
@ -94,23 +119,27 @@ multiprocessing_recv(PyObject *self, PyObject *args)
|
|||
return buf;
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.send
|
||||
|
||||
handle: HANDLE
|
||||
buf: Py_buffer
|
||||
/
|
||||
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
multiprocessing_send(PyObject *self, PyObject *args)
|
||||
_multiprocessing_send_impl(PyObject *module, HANDLE handle, Py_buffer *buf)
|
||||
/*[clinic end generated code: output=52d7df0519c596cb input=41dce742f98d2210]*/
|
||||
{
|
||||
HANDLE handle;
|
||||
Py_buffer buf;
|
||||
int ret, length;
|
||||
|
||||
if (!PyArg_ParseTuple(args, F_HANDLE "y*:send" , &handle, &buf))
|
||||
return NULL;
|
||||
|
||||
length = (int)Py_MIN(buf.len, INT_MAX);
|
||||
length = (int)Py_MIN(buf->len, INT_MAX);
|
||||
|
||||
Py_BEGIN_ALLOW_THREADS
|
||||
ret = send((SOCKET) handle, buf.buf, length, 0);
|
||||
ret = send((SOCKET) handle, buf->buf, length, 0);
|
||||
Py_END_ALLOW_THREADS
|
||||
|
||||
PyBuffer_Release(&buf);
|
||||
if (ret < 0)
|
||||
return PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());
|
||||
return PyLong_FromLong(ret);
|
||||
|
|
@ -118,18 +147,33 @@ multiprocessing_send(PyObject *self, PyObject *args)
|
|||
|
||||
#endif
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.sem_unlink
|
||||
|
||||
name: str
|
||||
/
|
||||
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
_multiprocessing_sem_unlink_impl(PyObject *module, const char *name)
|
||||
/*[clinic end generated code: output=fcbfeb1ed255e647 input=bf939aff9564f1d5]*/
|
||||
{
|
||||
return _PyMp_sem_unlink(name);
|
||||
}
|
||||
|
||||
/*
|
||||
* Function table
|
||||
*/
|
||||
|
||||
static PyMethodDef module_methods[] = {
|
||||
#ifdef MS_WINDOWS
|
||||
{"closesocket", multiprocessing_closesocket, METH_VARARGS, ""},
|
||||
{"recv", multiprocessing_recv, METH_VARARGS, ""},
|
||||
{"send", multiprocessing_send, METH_VARARGS, ""},
|
||||
_MULTIPROCESSING_CLOSESOCKET_METHODDEF
|
||||
_MULTIPROCESSING_RECV_METHODDEF
|
||||
_MULTIPROCESSING_SEND_METHODDEF
|
||||
#endif
|
||||
#if !defined(POSIX_SEMAPHORES_NOT_ENABLED) && !defined(__ANDROID__)
|
||||
{"sem_unlink", _PyMp_sem_unlink, METH_VARARGS, ""},
|
||||
_MULTIPROCESSING_SEM_UNLINK_METHODDEF
|
||||
#endif
|
||||
{NULL}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -88,6 +88,6 @@ PyObject *_PyMp_SetError(PyObject *Type, int num);
|
|||
*/
|
||||
|
||||
extern PyTypeObject _PyMp_SemLockType;
|
||||
extern PyObject *_PyMp_sem_unlink(PyObject *ignore, PyObject *args);
|
||||
extern PyObject *_PyMp_sem_unlink(const char *name);
|
||||
|
||||
#endif /* MULTIPROCESSING_H */
|
||||
|
|
|
|||
|
|
@ -21,6 +21,22 @@ typedef struct {
|
|||
char *name;
|
||||
} 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) (o->count > 0 && PyThread_get_thread_ident() == o->last_tid)
|
||||
|
||||
|
||||
|
|
@ -58,21 +74,24 @@ _GetSemaphoreValue(HANDLE handle, long *value)
|
|||
}
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock.acquire
|
||||
|
||||
block as blocking: bool(accept={int}) = True
|
||||
timeout as timeout_obj: object = None
|
||||
|
||||
Acquire the semaphore/lock.
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
|
||||
_multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
|
||||
PyObject *timeout_obj)
|
||||
/*[clinic end generated code: output=f9998f0b6b0b0872 input=86f05662cf753eb4]*/
|
||||
{
|
||||
int blocking = 1;
|
||||
double timeout;
|
||||
PyObject *timeout_obj = Py_None;
|
||||
DWORD res, full_msecs, nhandles;
|
||||
HANDLE handles[2], sigint_event;
|
||||
|
||||
static char *kwlist[] = {"block", "timeout", NULL};
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO", kwlist,
|
||||
&blocking, &timeout_obj))
|
||||
return NULL;
|
||||
|
||||
/* calculate timeout */
|
||||
if (!blocking) {
|
||||
full_msecs = 0;
|
||||
|
|
@ -146,8 +165,15 @@ semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
|
|||
}
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock.release
|
||||
|
||||
Release the semaphore/lock.
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_release(SemLockObject *self, PyObject *args)
|
||||
_multiprocessing_SemLock_release_impl(SemLockObject *self)
|
||||
/*[clinic end generated code: output=b22f53ba96b0d1db input=ba7e63a961885d3d]*/
|
||||
{
|
||||
if (self->kind == RECURSIVE_MUTEX) {
|
||||
if (!ISMINE(self)) {
|
||||
|
|
@ -264,19 +290,23 @@ sem_timedwait_save(sem_t *sem, struct timespec *deadline, PyThreadState *_save)
|
|||
|
||||
#endif /* !HAVE_SEM_TIMEDWAIT */
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock.acquire
|
||||
|
||||
block as blocking: bool(accept={int}) = True
|
||||
timeout as timeout_obj: object = None
|
||||
|
||||
Acquire the semaphore/lock.
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
|
||||
_multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
|
||||
PyObject *timeout_obj)
|
||||
/*[clinic end generated code: output=f9998f0b6b0b0872 input=86f05662cf753eb4]*/
|
||||
{
|
||||
int blocking = 1, res, err = 0;
|
||||
PyObject *timeout_obj = Py_None;
|
||||
int res, err = 0;
|
||||
struct timespec deadline = {0};
|
||||
|
||||
static char *kwlist[] = {"block", "timeout", NULL};
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO", kwlist,
|
||||
&blocking, &timeout_obj))
|
||||
return NULL;
|
||||
|
||||
if (self->kind == RECURSIVE_MUTEX && ISMINE(self)) {
|
||||
++self->count;
|
||||
Py_RETURN_TRUE;
|
||||
|
|
@ -345,8 +375,15 @@ semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
|
|||
Py_RETURN_TRUE;
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock.release
|
||||
|
||||
Release the semaphore/lock.
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_release(SemLockObject *self, PyObject *args)
|
||||
_multiprocessing_SemLock_release_impl(SemLockObject *self)
|
||||
/*[clinic end generated code: output=b22f53ba96b0d1db input=ba7e63a961885d3d]*/
|
||||
{
|
||||
if (self->kind == RECURSIVE_MUTEX) {
|
||||
if (!ISMINE(self)) {
|
||||
|
|
@ -429,19 +466,26 @@ newsemlockobject(PyTypeObject *type, SEM_HANDLE handle, int kind, int maxvalue,
|
|||
return (PyObject*)self;
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
@classmethod
|
||||
_multiprocessing.SemLock.__new__
|
||||
|
||||
kind: int
|
||||
value: int
|
||||
maxvalue: int
|
||||
name: str
|
||||
unlink: bool(accept={int})
|
||||
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
||||
_multiprocessing_SemLock_impl(PyTypeObject *type, int kind, int value,
|
||||
int maxvalue, const char *name, int unlink)
|
||||
/*[clinic end generated code: output=30727e38f5f7577a input=b378c3ee27d3a0fa]*/
|
||||
{
|
||||
SEM_HANDLE handle = SEM_FAILED;
|
||||
int kind, maxvalue, value, unlink;
|
||||
PyObject *result;
|
||||
char *name, *name_copy = NULL;
|
||||
static char *kwlist[] = {"kind", "value", "maxvalue", "name", "unlink",
|
||||
NULL};
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, kwds, "iiisi", kwlist,
|
||||
&kind, &value, &maxvalue, &name, &unlink))
|
||||
return NULL;
|
||||
char *name_copy = NULL;
|
||||
|
||||
if (kind != RECURSIVE_MUTEX && kind != SEMAPHORE) {
|
||||
PyErr_SetString(PyExc_ValueError, "unrecognized kind");
|
||||
|
|
@ -481,16 +525,25 @@ semlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
semlock_rebuild(PyTypeObject *type, PyObject *args)
|
||||
{
|
||||
SEM_HANDLE handle;
|
||||
int kind, maxvalue;
|
||||
char *name, *name_copy = NULL;
|
||||
/*[clinic input]
|
||||
@classmethod
|
||||
_multiprocessing.SemLock._rebuild
|
||||
|
||||
if (!PyArg_ParseTuple(args, F_SEM_HANDLE "iiz",
|
||||
&handle, &kind, &maxvalue, &name))
|
||||
return NULL;
|
||||
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]*/
|
||||
{
|
||||
char *name_copy = NULL;
|
||||
|
||||
if (name != NULL) {
|
||||
name_copy = PyMem_Malloc(strlen(name) + 1);
|
||||
|
|
@ -521,21 +574,42 @@ semlock_dealloc(SemLockObject* self)
|
|||
PyObject_Del(self);
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock._count
|
||||
|
||||
Num of `acquire()`s minus num of `release()`s for this process.
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_count(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
_multiprocessing_SemLock__count_impl(SemLockObject *self)
|
||||
/*[clinic end generated code: output=5ba8213900e517bb input=36fc59b1cd1025ab]*/
|
||||
{
|
||||
return PyLong_FromLong((long)self->count);
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock._is_mine
|
||||
|
||||
Whether the lock is owned by this thread.
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_ismine(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
_multiprocessing_SemLock__is_mine_impl(SemLockObject *self)
|
||||
/*[clinic end generated code: output=92dc98863f4303be input=a96664cb2f0093ba]*/
|
||||
{
|
||||
/* only makes sense for a lock */
|
||||
return PyBool_FromLong(ISMINE(self));
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock._get_value
|
||||
|
||||
Get the value of the semaphore.
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_getvalue(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
_multiprocessing_SemLock__get_value_impl(SemLockObject *self)
|
||||
/*[clinic end generated code: output=64bc1b89bda05e36 input=cb10f9a769836203]*/
|
||||
{
|
||||
#ifdef HAVE_BROKEN_SEM_GETVALUE
|
||||
PyErr_SetNone(PyExc_NotImplementedError);
|
||||
|
|
@ -552,8 +626,15 @@ semlock_getvalue(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
|||
#endif
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock._is_zero
|
||||
|
||||
Return whether semaphore has value zero.
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_iszero(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
_multiprocessing_SemLock__is_zero_impl(SemLockObject *self)
|
||||
/*[clinic end generated code: output=815d4c878c806ed7 input=294a446418d31347]*/
|
||||
{
|
||||
#ifdef HAVE_BROKEN_SEM_GETVALUE
|
||||
if (sem_trywait(self->handle) < 0) {
|
||||
|
|
@ -573,38 +654,68 @@ semlock_iszero(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
|||
#endif
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_multiprocessing.SemLock._after_fork
|
||||
|
||||
Rezero the net acquisition count after fork().
|
||||
[clinic start generated code]*/
|
||||
|
||||
static PyObject *
|
||||
semlock_afterfork(SemLockObject *self, PyObject *Py_UNUSED(ignored))
|
||||
_multiprocessing_SemLock__after_fork_impl(SemLockObject *self)
|
||||
/*[clinic end generated code: output=718bb27914c6a6c1 input=190991008a76621e]*/
|
||||
{
|
||||
self->count = 0;
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_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=c5e27d594284690b]*/
|
||||
{
|
||||
return _multiprocessing_SemLock_acquire_impl(self, 1, Py_None);
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
_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=7d644b64a89903f8]*/
|
||||
{
|
||||
return _multiprocessing_SemLock_release_impl(self);
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore methods
|
||||
*/
|
||||
|
||||
static PyMethodDef semlock_methods[] = {
|
||||
{"acquire", (PyCFunction)(void(*)(void))semlock_acquire, METH_VARARGS | METH_KEYWORDS,
|
||||
"acquire the semaphore/lock"},
|
||||
{"release", (PyCFunction)semlock_release, METH_NOARGS,
|
||||
"release the semaphore/lock"},
|
||||
{"__enter__", (PyCFunction)(void(*)(void))semlock_acquire, METH_VARARGS | METH_KEYWORDS,
|
||||
"enter the semaphore/lock"},
|
||||
{"__exit__", (PyCFunction)semlock_release, METH_VARARGS,
|
||||
"exit the semaphore/lock"},
|
||||
{"_count", (PyCFunction)semlock_count, METH_NOARGS,
|
||||
"num of `acquire()`s minus num of `release()`s for this process"},
|
||||
{"_is_mine", (PyCFunction)semlock_ismine, METH_NOARGS,
|
||||
"whether the lock is owned by this thread"},
|
||||
{"_get_value", (PyCFunction)semlock_getvalue, METH_NOARGS,
|
||||
"get the value of the semaphore"},
|
||||
{"_is_zero", (PyCFunction)semlock_iszero, METH_NOARGS,
|
||||
"returns whether semaphore has value zero"},
|
||||
{"_rebuild", (PyCFunction)semlock_rebuild, METH_VARARGS | METH_CLASS,
|
||||
""},
|
||||
{"_after_fork", (PyCFunction)semlock_afterfork, METH_NOARGS,
|
||||
"rezero the net acquisition count after fork()"},
|
||||
_MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF
|
||||
_MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF
|
||||
{NULL}
|
||||
};
|
||||
|
||||
|
|
@ -666,7 +777,7 @@ PyTypeObject _PyMp_SemLockType = {
|
|||
/* tp_dictoffset */ 0,
|
||||
/* tp_init */ 0,
|
||||
/* tp_alloc */ 0,
|
||||
/* tp_new */ semlock_new,
|
||||
/* tp_new */ _multiprocessing_SemLock,
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -674,13 +785,8 @@ PyTypeObject _PyMp_SemLockType = {
|
|||
*/
|
||||
|
||||
PyObject *
|
||||
_PyMp_sem_unlink(PyObject *ignore, PyObject *args)
|
||||
_PyMp_sem_unlink(const char *name)
|
||||
{
|
||||
char *name;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "s", &name))
|
||||
return NULL;
|
||||
|
||||
if (SEM_UNLINK(name) < 0) {
|
||||
_PyMp_SetError(NULL, MP_STANDARD_ERROR);
|
||||
return NULL;
|
||||
|
|
|
|||
Loading…
Reference in New Issue