From 38d3724b2af3c2b08c548326797c2421b054c846 Mon Sep 17 00:00:00 2001 From: cbdev Date: Sun, 8 Mar 2020 13:24:33 +0100 Subject: Implement python intervaling and socket management --- backends/python.c | 294 +++++++++++++++++++++++++++++++++++++++++++++++++++-- backends/python.h | 19 ++++ backends/python.md | 44 +++++++- 3 files changed, 346 insertions(+), 11 deletions(-) diff --git a/backends/python.c b/backends/python.c index 9fad0ae..70c2548 100644 --- a/backends/python.c +++ b/backends/python.c @@ -7,13 +7,14 @@ #define MMPY_INSTANCE_KEY "midimonster_instance" -/* - * TODO might want to export the full MM_API set to python at some point - */ - static PyThreadState* python_main = NULL; static wchar_t* program_name = NULL; +static uint64_t last_timestamp = 0; +static uint32_t timer_interval = 0; +static size_t intervals = 0; +static mmpy_timer* interval = NULL; + MM_PLUGIN_API int init(){ backend python = { .name = BACKEND_NAME, @@ -24,6 +25,7 @@ MM_PLUGIN_API int init(){ .handle = python_set, .process = python_handle, .start = python_start, + .interval = python_interval, .shutdown = python_shutdown }; @@ -35,6 +37,57 @@ MM_PLUGIN_API int init(){ return 0; } +static uint32_t python_interval(){ + size_t u = 0; + uint32_t next_timer = 1000; + + if(timer_interval){ + for(u = 0; u < intervals; u++){ + if(interval[u].interval && + interval[u].interval - interval[u].delta < next_timer){ + next_timer = interval[u].interval - interval[u].delta; + } + } + DBGPF("Next timer fires in %" PRIu32, next_timer); + return next_timer; + } + + return 1000; +} + +static void python_timer_recalculate(){ + uint64_t next_interval = 0, gcd, residual; + size_t u; + + //find lower interval bounds + for(u = 0; u < intervals; u++){ + if(interval[u].interval && (!next_interval || interval[u].interval < next_interval)){ + next_interval = interval[u].interval; + } + } + + if(next_interval){ + for(u = 0; u < intervals; u++){ + if(interval[u].interval){ + //calculate gcd of current interval and this timers interval + gcd = interval[u].interval; + while(gcd){ + residual = next_interval % gcd; + next_interval = gcd; + gcd = residual; + } + + //10msec is absolute lower limit and minimum gcd due to rounding + if(next_interval == 10){ + break; + } + } + } + } + + timer_interval = next_interval; +} + static int python_configure(char* option, char* value){ LOG("No backend configuration possible"); return 1; @@ -64,7 +117,7 @@ static PyObject* mmpy_output(PyObject* self, PyObject* args){ const char* channel_name = NULL; channel* chan = NULL; channel_value val = { - 0 + {0} }; size_t u; @@ -137,6 +190,163 @@ static PyObject* mmpy_input_value(PyObject* self, PyObject* args){ return mmpy_channel_value(self, args, 1); } +static PyObject* mmpy_timestamp(PyObject* self, PyObject* args){ + return PyLong_FromUnsignedLong(mm_timestamp()); +} + +static PyObject* mmpy_interval(PyObject* self, PyObject* args){ + instance* inst = *((instance**) PyModule_GetState(self)); + python_instance_data* data = (python_instance_data*) inst->impl; + unsigned long updated_interval = 0; + PyObject* reference = NULL; + size_t u; + + if(!PyArg_ParseTuple(args, "Ok", &reference, &updated_interval)){ + return NULL; + } + + if(!PyCallable_Check(reference)){ + PyErr_SetString(PyExc_TypeError, "interval() requires a callable"); + return NULL; + } + + //round interval + if(updated_interval % 10 < 5){ + updated_interval -= updated_interval % 10; + } + else{ + updated_interval += (10 - (updated_interval % 10)); + } + + //find reference + for(u = 0; u < intervals; u++){ + if(interval[u].interpreter == data->interpreter + && PyObject_RichCompareBool(reference, interval[u].reference, Py_EQ) == 1){ + DBGPF("Updating interval to %" PRIu64 " msec", updated_interval); + break; + } + } + + //register new interval + if(u == intervals && updated_interval){ + //create new interval slot + DBGPF("Registering interval with %" PRIu64 " msec", updated_interval); + interval = realloc(interval, (intervals + 1) * sizeof(mmpy_timer)); + if(!interval){ + intervals = 0; + LOG("Failed to allocate memory"); + return NULL; + } + Py_INCREF(reference); + interval[intervals].delta = 0; + interval[intervals].reference = reference; + interval[intervals].interpreter = data->interpreter; + intervals++; + } + + //update if existing or created + if(u < intervals){ + interval[u].interval = updated_interval; + python_timer_recalculate(); + } + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject* mmpy_manage_fd(PyObject* self, PyObject* args){ + instance* inst = *((instance**) PyModule_GetState(self)); + python_instance_data* data = (python_instance_data*) inst->impl; + PyObject* handler = NULL, *sock = NULL, *fileno = NULL; + size_t u = 0, last_free = 0; + int fd = -1; + + if(!PyArg_ParseTuple(args, "OO", &handler, &sock)){ + return NULL; + } + + if(handler != Py_None && !PyCallable_Check(handler)){ + PyErr_SetString(PyExc_TypeError, "manage() requires either None or a callable"); + return NULL; + } + + fileno = PyObject_CallMethod(sock, "fileno", NULL); + if(!fileno || fileno == Py_None || !PyLong_Check(fileno)){ + PyErr_SetString(PyExc_TypeError, "manage() requires a socket-like object"); + return NULL; + } + + fd = PyLong_AsLong(fileno); + if(fd < 0){ + PyErr_SetString(PyExc_TypeError, "manage() requires a (connected) socket-like object"); + return NULL; + } + + //check if this socket instance was already registered + last_free = data->sockets; + for(u = 0; u < data->sockets; u++){ + if(!data->socket[u].socket){ + last_free = u; + } + else if(PyObject_RichCompareBool(sock, data->socket[u].socket, Py_EQ) == 1){ + break; + } + } + + if(u < data->sockets){ + //modify existing socket + Py_XDECREF(data->socket[u].handler); + if(handler != Py_None){ + DBGPF("Updating handler for fd %d on %s", fd, inst->name); + data->socket[u].handler = handler; + Py_INCREF(handler); + } + else{ + DBGPF("Unregistering fd %d on %s", fd, inst->name); + mm_manage_fd(data->socket[u].fd, BACKEND_NAME, 0, NULL); + Py_XDECREF(data->socket[u].socket); + data->socket[u].handler = NULL; + data->socket[u].socket = NULL; + data->socket[u].fd = -1; + } + } + else if(handler != Py_None){ + //check that the fd is not already registered with another socket instance + for(u = 0; u < data->sockets; u++){ + if(data->socket[u].fd == fd){ + //FIXME this might also raise an exception + LOGPF("Descriptor already registered with another socket on instance %s", inst->name); + Py_INCREF(Py_None); + return Py_None; + } + } + + DBGPF("Registering new fd %d on %s", fd, inst->name); + if(last_free == data->sockets){ + //allocate a new socket instance + data->socket = realloc(data->socket, (data->sockets + 1) * sizeof(mmpy_socket)); + if(!data->socket){ + data->sockets = 0; + LOG("Failed to allocate memory"); + return NULL; + } + data->sockets++; + } + + //store new reference + //FIXME check this for errors + mm_manage_fd(fd, BACKEND_NAME, 1, inst); + data->socket[last_free].fd = fd; + Py_INCREF(handler); + data->socket[last_free].handler = handler; + Py_INCREF(sock); + data->socket[last_free].socket = sock; + } + + Py_INCREF(Py_None); + return Py_None; +} + static int mmpy_exec(PyObject* module) { instance** inst = (instance**) PyModule_GetState(module); //FIXME actually use interpreter dict (from python 3.8) here at some point @@ -146,7 +356,7 @@ static int mmpy_exec(PyObject* module) { return 0; } - //TODO raise exception + PyErr_SetString(PyExc_AssertionError, "Failed to pass instance pointer for initialization"); return -1; } @@ -184,6 +394,9 @@ static PyObject* mmpy_init(){ {"inputvalue", mmpy_input_value, METH_VARARGS, "Get last input value for a channel"}, {"outputvalue", mmpy_output_value, METH_VARARGS, "Get the last output value for a channel"}, {"current", mmpy_current_handler, METH_VARARGS, "Get the name of the currently executing channel handler"}, + {"timestamp", mmpy_timestamp, METH_VARARGS, "Get the core timestamp (in milliseconds)"}, + {"manage", mmpy_manage_fd, METH_VARARGS, "(Un-)register a socket or file descriptor for notifications"}, + {"interval", mmpy_interval, METH_VARARGS, "Register or update an interval handler"}, {0} }; @@ -324,12 +537,66 @@ static int python_set(instance* inst, size_t num, channel** c, channel_value* v) } } + //release interpreter PyEval_ReleaseThread(data->interpreter); return 0; } static int python_handle(size_t num, managed_fd* fds){ - //TODO implement some kind of intervaling functionality before people get it in their heads to start `import threading` + instance* inst = NULL; + python_instance_data* data = NULL; + PyObject* result = NULL; + size_t u, p; + + //handle intervals + if(timer_interval){ + uint64_t delta = mm_timestamp() - last_timestamp; + last_timestamp = mm_timestamp(); + + //add delta to all active timers + for(u = 0; u < intervals; u++){ + if(interval[u].interval){ + interval[u].delta += delta; + + //if timer expired, call handler + if(interval[u].delta >= interval[u].interval){ + interval[u].delta %= interval[u].interval; + + //swap to interpreter + PyEval_RestoreThread(interval[u].interpreter); + //call handler + result = PyObject_CallFunction(interval[u].reference, NULL); + Py_XDECREF(result); + //release interpreter + PyEval_ReleaseThread(interval[u].interpreter); + DBGPF("Calling interval handler %" PRIsize_t, u); + } + } + } + } + + for(u = 0; u < num; u++){ + inst = (instance*) fds[u].impl; + data = (python_instance_data*) inst->impl; + + //swap to interpreter + PyEval_RestoreThread(data->interpreter); + + //handle callbacks + for(p = 0; p < data->sockets; p++){ + if(data->socket[p].socket + && data->socket[p].fd == fds[u].fd){ + //FIXME maybe close/unregister the socket on handling errors + DBGPF("Calling descriptor handler on %s for fd %d", inst->name, data->socket[p].fd); + result = PyObject_CallFunction(data->socket[p].handler, "O", data->socket[p].socket); + Py_XDECREF(result); + } + } + + //release interpreter + PyEval_ReleaseThread(data->interpreter); + } + return 0; } @@ -396,6 +663,19 @@ static int python_shutdown(size_t n, instance** inst){ for(u = 0; u < n; u++){ data = (python_instance_data*) inst[u]->impl; + + //close sockets + for(p = 0; p < data->sockets; p++){ + close(data->socket[p].fd); //FIXME does python do this on its own? + Py_XDECREF(data->socket[p].socket); + Py_XDECREF(data->socket[p].handler); + } + + //release interval references + for(p = 0; p name); //swap to interpreter and end it, GIL is held after this but state is NULL PyThreadState_Swap(data->interpreter); diff --git a/backends/python.h b/backends/python.h index 10411ca..8ca12f9 100644 --- a/backends/python.h +++ b/backends/python.h @@ -1,6 +1,7 @@ #include "midimonster.h" MM_PLUGIN_API int init(); +static uint32_t python_interval(); static int python_configure(char* option, char* value); static int python_configure_instance(instance* inst, char* option, char* value); static int python_instance(instance* inst); @@ -17,8 +18,26 @@ typedef struct /*_python_channel_data*/ { double out; } mmpython_channel; +typedef struct /*_mmpy_registered_socket*/ { + int fd; + PyObject* handler; + PyObject* socket; +} mmpy_socket; + +typedef struct /*_mmpy_interval*/ { + uint64_t interval; + uint64_t delta; + PyObject* reference; + PyThreadState* interpreter; +} mmpy_timer; + typedef struct /*_python_instance_data*/ { PyThreadState* interpreter; + PyObject* config; //TODO + + size_t sockets; + mmpy_socket* socket; + size_t channels; mmpython_channel* channel; mmpython_channel* current_channel; diff --git a/backends/python.md b/backends/python.md index fae3139..b6a1162 100644 --- a/backends/python.md +++ b/backends/python.md @@ -7,6 +7,9 @@ Every instance has its own interpreter, which can be loaded with multiple Python These modules may contain member functions accepting a single `float` parameter, which can then be used as target channels. For each incoming event, the handler function is called. +Python modules may also register `socket` objects (and an associated callback function) with +the MIDIMonster core, which will then alert the module when there is data ready to be read. + To interact with the MIDIMonster core, import the `midimonster` module from within your module. The `midimonster` module provides the following functions: @@ -17,17 +20,47 @@ The `midimonster` module provides the following functions: | `inputvalue(string)` | `midimonster.inputvalue("foo")` | Get the last input value on a channel | | `outputvalue(string)` | `midimonster.outputvalue("bar")` | Get the last output value on a channel | | `current()` | `print(midimonster.current())` | Returns the name of the input channel whose handler function is currently running or `None` if the interpreter was called from another context | +| `timestamp()` | `print(midimonster.timestamp())` | Get the internal core timestamp (in milliseconds) | +| `interval(function, long)` | `midimonster.interval(toggle, 100)` | Register a function to be called periodically. Interval is specified in milliseconds (accurate to 10msec). Calling `interval` with the same function again updates the interval. Specifying the interval as `0` cancels the interval | +| `manage(function, socket)` | `midimonster.manage(handler, socket)`| Register a (connected/listening) socket to the MIDIMonster core. Calls `function(socket)` when the socket is ready to read. Calling this method with `None` as the function argument unregisters the socket. A socket may only have one associated handler | Example Python module: ``` +import socket import midimonster +# Simple channel ahndler def in1(value): midimonster.output("out1", 1 - value) + +# Socket data handler +def socket_handler(sock): + # This should get some more error handling + data = sock.recv(1024) + print("Received %d bytes from socket: %s" % (len(data), data)) + if(len(data) == 0): + # Unmanage the socket if it has been closed + midimonster.manage(None, sock) + sock.close() + +# Interval handler +def ping(): + print(midimonster.interval()) + +# Register an interval +midimonster.interval(ping, 1000) +# Create and register a client socket (add error handling as you like) +s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) +s.connect(("localhost", 8990)) +midimonster.manage(reader, s) ``` Input values range between 0.0 and 1.0, output values are clamped to the same range. +Note that registered sockets that have been closed (`socket.recv()` returned 0 bytes) +need to be unregistered from the MIDIMonster core, otherwise the core socket multiplexing +mechanism will report an error and shut down the MIDIMonster. + #### Global configuration The `python` backend does not take any global configuration. @@ -49,7 +82,7 @@ specify the channel as the functions qualified path (by prefixing it with the mo Example mappings: ``` py1.my_handlers.in1 < py1.foo -py1.out1 > py2.module.handler +py1.out1 > py2.module.handler ``` #### Known bugs / problems @@ -57,7 +90,10 @@ py1.out1 > py2.module.handler Output values will not trigger corresponding input event handlers unless the channel is mapped back in the MIDIMonster configuration. This is intentional. -Importing a Python module named `midimonster` may cause problems and is unsupported. +Importing a Python module named `midimonster` is probably a bad idea and thus unsupported. + +The MIDIMonster is, at its core, single-threaded. Do not try to use Python's `threading` +module with the MIDIMonster. -There is currently no functionality for cyclic execution. This may be implemented in a future -release. +Note that executing Python code blocks the MIDIMonster core. It is not a good idea to call functions that +take a long time to complete (such as `time.sleep()`) within your Python modules. -- cgit v1.2.3