I am working on implementing Python bindings for a real-time C library of mine. I have read that threads in Python are not actual threads and that they don't really run in parallel (because of the Global Interpreter Lock). Nevertheless, I would have to consider the following situation.
Imagine the following C function:
int stoppable_lock(mutex *m, bool *stop)
{
while (!stop || !*stop)
if (timed_lock(m, SOME_TIME) == SUCCESS)
return SUCCESS;
return DIDNT_LOCK;
}
This function waits on a mutex, but through the use of stop
, can be cancelled. In the simplest case, to be able to gracefully stop the thread using it, no matter what happens to the other users of the mutex (for example if they die while holding the lock).
My problem is to figure out how to write a Python wrapper for this function. By parsing the arguments (with PyArg_ParseTuple
) I can retrieve the mutex, no problem. However, the type of things that can be sent to the function seem to be strings, numbers and objects. The first two obviously cannot replace a bool *
, and I doubt writing a wrapper for bool *
is a good idea.
My question is, how can I get a parameter, which is a reference to a variable (shared with other python threads) and not just a copy of it?
Here is the function with the piece I'm missing (for a usage like mutex.stoppable_lock(stop)
):
static PyObject *_stoppable_lock(_mutex *obj, PyObject *args)
{
int ret;
BOOL_STAR stop;
if (!PyArg_ParseTuple(args, "?", &stop))
{
PyErr_SetString(PyExc_ValueError, "Usage: mutex.stoppable_lock(BOOL_STAR)");
return NULL;
}
ret = stoppable_lock(obj->orig, stop);
if (_set_exception(ret))
return NULL;
Py_RETURN_NONE;
}
Where it is unknown to me what BOOL_STAR
and "?"
should be.