HN Explorer

Show HN: Copy-and-patch compiler for hard real-time Python (github.com)

65 points by Saloc ↗ HN
I built Copapy as an experiment: Can Python be used for hard real-time systems?

Instead of an interpreter or JIT, Copapy builds a computation graph by tracing Python code and uses a custom copy-and-patch compiler. The result is very fast native code with no GC, no syscalls, and no memory allocations at runtime.

The copy-and-patch compiler currently supports x86_64 as well as 32- and 64-bit ARM. It comes as small Python package with no other dependencies - no cross-compiler, nothing except Python.

The current focus is on robotics and control systems in general. This project is early but already usable and easy to try out.

Would love your feedback!

10 comments

[ 3.0 ms ] story [ 33.5 ms ] thread
genjipress
This looks like it could become an excellent alternative in time to not just NumPy and Numba, but also Cython. I know that may be more ambitious than your original intentions, but that's absolutely what sprung to mind.
written-beyond
THAT'S INSANE!

I always wondered if this could be possible. Like you fuzz a program, map out each possible allocation and deallocation and optimize the code with those hot paths and some statistics.

Very interesting project, would love some sort of write up on it.

[dead] newzino
[flagged]
Saloc
In some fields its quite common to implement state machines in an imperative style with if-blocks and flags. That should be possible with Copapy by having decorated functions where the decorator parses the AST and replaces if-blocks with cp.iif() to end up with branchless code.

However, from my experience this programming style is ok for simple state machines, but it’s definitely not great, and if things get more complex, it’s getting really hard to keep it comprehensible and correct.

I think the main challenge is the design of an API that fits state machines. Concerning the WCET, branchless code should be on average not worse than branched code.

[deleted]
(comment deleted)
bigbadfeline
> The result is very fast native code with no GC, no syscalls, and no memory allocations at runtime.

I guess, that's only achievable for certain kind of code, already designed with hard real-time in mind. It would be good to have some information about the limitations of this approach.

nmstoker
Impressive stuff but it would be polite to the potentially interested users if the line, "... this package is currently a proof of concept with limited direct use", had been put a little earlier. It's about nine or so dense paragraphs in.

It's fine that it is still in development but it just seems worth being upfront.

vsskanth
How is this different to casadi ?
Saloc
Casadi uses either an interpreter or emits c-code, where Copapy directly runs machine code. Would be very interesting to benchmark Copapy against compiled Casadi c-code – looking into it.
TheCodeDecoders
Try using Nanobind . Even though Python C API is what you aim for Nanobind has smaller binary files than pybind11. It is a reputed project and is deployed in many new libraries. Including mine. Will it work?