ABOUT

This is a relatively simple IPC buffer that allows multiple processes and threads to share a dynamic heap allocator, designate "channels" between processes, and share that memory between producer/consumer pairs on those channels.

Currently implemented is the following:

• multi-threaded/multi-process allocation via priority heap
• per-thread TLS lock-free allocation slab
• single-producer, single-consumer channel (multi-process and multi-threaded)
• multiple channels per buffer (you can have as many independent channels as you want till you run out of memory).
• named static shared memory segment (as a channel) which can be used for synchronization or other purposes where message passing semantics aren't useful.

Status -

Currently testing the following combinations

• Linux
  • POSIX SHM + POSIX Semaphores
  • POSIX SHM + SystemV Semaphors
  • SystemV SHM + POSIX Semaphores
  • SystemV SHM + SystemV Semaphors
• OS X
  • POSIX SHM + SystemV Semaphores

Why

• Lack of existing simple point-to-point multi-process allocation and communication mechanisms.

Simple example

/** only include file you should need **/
#include<buffer>/** * shared memory buffer allocated and returned as a pointer, * this function can be called from each process safely to get * the file descriptor opened and memory opened within your  * address space. */auto *buffer = ipc::buffer::initialize( "thehandle" );
/** get a thread local data structure for the buffer with thread id **/auto *tls_producer = ipc::buffer::get_tls_structure( buffer,
thread_id );
constauto channel_id = 1;
/** * allocate a channel that is a single-producer, single consumer * record channel, record channels are used for larger allocations * up to 1MiB. The consumer must know that channel_id is the correct * channel and also the type of channel otherwise an error will be  * thrown. */ipc::buffer::add_spsc_lf_record_channel( tls_producer, channel_id )
/** get some memory and do something with it **/
int *output = (int*)
/** currently single allocations limited to 1MiB **/
ipc::buffer::allocate_record( tls_producer, sizeof( int ), channel_id );
/** lock-free record send **/while( ipc::buffer::send_record( tls_producer, channel_id, (void**)&output ) != ipc::tx_success );
//NOTE: consumer side has equiv lock-free receive record/** close tls **/ipc::buffer::close_tls_structure( tls_producer );
/** destroy the buffer **/ipc::buffer::destruct( buffer /** buffer ptr **/, "thehandle"/** file handle **/, true/** unlink, true if you're the last user **/);

Compiling

Currently only for Linux and OS X systems. Will add Windows soon. Compiles with gcc 9+ and clang 10+.

git clone https://github.com/RaftLib/ipc.git
cd ipc
cmake ../ make -j
make test

Usage notes

Will add more notes soon. Most complete example with two processes and two threads (1 process communicating with another process that has two threads) is here

• NOTE: the combination of OS X + SystemV Shared Memory + SystemV Semaphores is currently not passing tests, will investigate. All other combinations on OS X and Linux work.