Untrusted IPC with maximum performance and minimum latency. On Rust, on Linux.
- Performance or latency is crucial, and
- you run Linux.
A typical use case could be audio/video streaming.
Don't need maximum performance and minimum latency, and want a higher level protocol with serialization and lots of bells and whistles built-in? Try D-Bus.
Also, a unix socket is easier to set up and is not that much slower (see benchmark below).
As for Linux, this crate uses memfd sealing to ensure safety between untrusted processes, and ringbuffer signaling is done using eventfd for best performance. These two features are Linux only.
You probably want to start in the sharedring module, which sets up a ringbuffer
between untrusted processes (it's a wait-free/lock-free, bounded, SPSC queue).
Another useful function is mem::write_once for a scenario where
you write data once and make it available for reading afterwards. The mem and ringbuf
modules contain building blocks that might be useful in other use cases.
The downside of using memfd based shared memory is that you need to set it up by transferring file descriptors, using some other way of communication. Using D-Bus would be the standard way of doing that - it's also possible using unix sockets.
There is also a client/server example in the examples directory that can help you get started.
Enjoy!
Notice the log scale: for a 64K packet, sharedring is a three times faster than unix sockets,
and 60 times faster than D-Bus. (D-Bus is a higher level protocol, so that comparison
is to some degree comparing apples and oranges.)
The code is Apache 2.0 / MIT dual licensed. Any code submitted in Pull Requests, discussions or issues is assumed to have this license, unless explicitly stated otherwise.
