sharify

Back Rust types with shared memory and send them cheaply between processes.

For example

use sharify::SharedMut;
use std::{iter, sync::mpsc::channel, thread};

// Create a slice backed by shared memory.
let mut shared_slice: SharedMut<[u64]> = SharedMut::new(&(0, 1_000_000))?;

// Write some data to it.
for (src, dst) in
    iter::successors(Some(0), |&p| Some(p + 1))
    .zip(shared_slice.as_view_mut().iter_mut())
{
    *dst = src;
}

// The shared slice can be sent between processes cheaply without copying the data. What is shown here for threads works equally well for processes, e.g. using the ipc_channel crate.
let (tx, rx) = channel::<SharedMut<[u64]>>();
let handle = thread::spawn(move || {
    let shared_slice = rx.recv().unwrap();
    // Get a view into the shared memory
    let view: &[u64] = shared_slice.as_view();
    assert_eq!(view.len(), 1_000_000);
    assert!(iter::successors(Some(0), |&p| Some(p + 1))
        .zip(view.iter())
        .all(|(a, &b)| a == b));
});
tx.send(shared_slice)?;
handle.join().unwrap();

See the docs for details on how to do this for your own types. Requires at least Rust 1.51.0 due to the use of const generics.