Struct ShmemConf 

pub struct ShmemConf { /* private fields */ }

A representation of a mapped shared memory.

Implementations

impl ShmemConf

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

Converts ShmemConf’s raw pointer to a boxed pointer of type T.

Safety

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

Examples

use std::mem;
use shmem_bind::{self as shmem,ShmemError};

type NotZeroI32 = i32;

fn main() -> Result<(),ShmemError>{
    let shared_mem = shmem::Builder::new("flink_test_boxed")
        .with_size(mem::size_of::<NotZeroI32>() as i64)
        .open()?;

    let boxed_val = unsafe {
        // the allocated shared_memory is not initialized and thus, not guaranteed to be a
        // valid `NotZeroI32`
        let mut boxed_val = shared_mem.boxed::<NotZeroI32>();
        // manually initialize the value in the unsafe block
        *boxed_val = 5;
        boxed_val
    };

    assert_eq!(*boxed_val, 5);

    let shared_mem = shmem::Builder::new("flink_test_boxed")
        .with_size(mem::size_of::<NotZeroI32>() as i64)
        .open()?;

    let mut boxed_barrow_val = unsafe { shared_mem.boxed::<NotZeroI32>() };

    assert_eq!(*boxed_barrow_val, 5);

    // changes to boxed_barrow_val would reflect to boxed_val as well since they both point
    // to the same location.
    *boxed_barrow_val = 3;
    assert_eq!(*boxed_val, 3);
     
    Ok(())
}

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.