Struct shmem_bind::ShmemConf

pub struct ShmemConf { /* private fields */ }

Implementations

impl ShmemConf

pub unsafe fn boxed<T>(self) -> ShmemBox<T>

Safety

this is unsafe because there is no guarantee that the referred T is initialized. the caller must ensure that the value behind the pointer is initialzed before use

Examples found in repository

examples/message-passing.rs (line 32)

fn main() -> Result<(), Box<dyn Error>> {
    // create new shared memory pointer with desired size
    //
    // first call to this function with the same FILE_LINK_ID would result in creating a new shared
    // memory file and owning it. this would result in deleting the shared memory when the variable
    // goes out of scope.
    // the second call to this function will only open shared memory and would not delete it.
    let shared_mem = shmem::Builder::new("shmem-example_message-passing.shm")
        .with_size(mem::size_of::<Message>() as i64)
        .open()?;

    // wrap the raw shared memory ptr with desired Boxed type
    // user must ensure that the data the pointer is pointing to is initialized and valid for use
    let mut message = unsafe { shared_mem.boxed::<Message>() };

    let mut args = std::env::args();
    let num_args = args.len();
    match num_args {
        // parent process
        1 => {
            // ensure that first process owns the shared memory (used for cleanup)
            let mut message = ShmemBox::own(message);

            // initiate the data behind the boxed pointer
            message.val = 1;

            let binary_path = args.next().unwrap();
            let new_val = 5;
            // create new process to mutate the shared memory
            let mut handle = Command::new(&binary_path)
                .arg(format!("{new_val}"))
                .spawn()
                .unwrap();
            handle.wait()?;

            // assert that the new process mutated the shared memory
            assert_eq!(message.val, new_val);

            // message is dropped here, shared memory IS deallocated
        }
        // child process
        2 => {
            let value = std::env::args().last().unwrap().parse()?;

            message.val = value;

            // message is dropped here, shared memory IS NOT deallocated
        }
        _ => unimplemented!(),
    }
    Ok(())
}

Trait Implementations

impl Debug for ShmemConf

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for ShmemConf

fn drop(&mut self)

Executes the destructor for this type.