Using a Co-processor to Interpret Dynamic Modules while Executing Processor Stays Running

[oclyke]

Hi everyone, I am working on a project where users may dynamically add plugins during runtime. I ran into an issue because, presumably, the _ _ import _ _() call I am making must block execution while it prepares the dynamic module for execution (compiles the code to bytecode, moves that bytecode into memory, and perhaps more(???)). It is a detriment to my application for this pause to happen (takes on the order of seconds) because the modules are meant to augment a simple animation on addressable LEDs and the pause breaks immersion.

I got to wondering if it would be possible for a coprocessor to receive and compile the code to byte code in parallel to the main processor executing the main functionality. I am reaching out to ask if anyone knows ahead of time whether this is a total fools errand. Is there some magic step where the main task must know about results of the compilation? Does compiling code into bytecode require context from the execution environment?

Is there something I am missing? Perhaps another way to solve this issue?

Thanks in advance for taking the time to share a little wisdom here.

[dlech]

If you use mpy-cross to compile plugins to .mpy files ahead of time, then that would remove that compiling to bytecode step entirely.

[oclyke]

That's great! In this case I can in fact pre-compile the modules with mpy-cross. I use a lot of other frozen modules as part of the regular firmware and I've noticed that importing these files can take quite some time as well. I suppose I should profile the code to see how much time is spent compiling and how much is spent in other tasks (running module level code, or something else I am unaware of yet)

[peterhinch]

Frozen modules are stored as bytecode in flash, so importing these does not involve the compiler. It's usually fast.