Struct LlmpSender 

pub struct LlmpSender<SHM, SP> { /* private fields */ }

Sending end on a (unidirectional) sharedmap channel

Implementations

impl<SHM, SP> LlmpSender<SHM, SP>

where SHM: ShMem, SP: ShMemProvider<ShMem = SHM>,

An actor on the sending part of the shared map

pub fn new( shmem_provider: SP, id: ClientId, keep_pages_forever: bool, ) -> Result<Self, Error>

Create a new LlmpSender using a given ShMemProvider, and id. If keep_pages_forever is true, ShMem will never be freed. If it is false, the pages will be unmapped once they are full, and have been mapped by at least one LlmpReceiver.

pub fn on_existing_from_env( shmem_provider: SP, env_name: &str, ) -> Result<Self, Error>

Reattach to a vacant out_shmem, to with a previous sender stored the information in an env before.

pub fn on_existing_shmem( shmem_provider: SP, current_out_shmem: SHM, last_msg_sent_offset: Option<u64>, ) -> Result<Self, Error>

Reattach to a vacant out_shmem. It is essential, that the receiver (or someone else) keeps a pointer to this map else reattach will get a new, empty page, from the OS, or fail.

pub fn alloc_next(&mut self, buf_len: usize) -> Result<*mut LlmpMsg, Error>

Allocates the next space on this sender page

pub unsafe fn cancel_send(&mut self, msg: *mut LlmpMsg)

Cancel send of the next message, this allows us to allocate a new message without sending this one.

Safety

They msg pointer may no longer be used after cancel_send

pub unsafe fn shrink_alloced( &mut self, msg: *mut LlmpMsg, shrinked_len: usize, ) -> Result<(), Error>

Shrinks the allocated LlmpMsg to a given size.

Safety

The msg pointer will be dereferenced, if it’s not null.

pub fn send_buf(&mut self, tag: Tag, buf: &[u8]) -> Result<(), Error>

Allocates a message of the given size, tags it, and sends it off.

pub fn send_buf_with_flags( &mut self, tag: Tag, flags: Flags, buf: &[u8], ) -> Result<(), Error>

Send a buf with the given flags.

pub fn on_existing_from_description( shmem_provider: SP, description: &LlmpDescription, ) -> Result<Self, Error>

Create this client on an existing map from the given description. Acquired with LlmpSender::describe.

pub fn send_exiting(&mut self) -> Result<(), Error>

Send information that this client is exiting. The other side may free up all allocated memory. We are no longer allowed to send anything afterwards.

Examples found in repository

examples/llmp_test/main.rs (line 236)

fn main() -> Result<(), Box<dyn core::error::Error>> {
    /* The main node has a broker, and a few worker threads */

    use ll_mp::Broker;

    let mode = std::env::args()
        .nth(1)
        .expect("no mode specified, chose 'broker', 'b2b', 'ctr', 'adder', 'large', or 'exiting'");
    let port: u16 = std::env::args()
        .nth(2)
        .unwrap_or_else(|| "1337".into())
        .parse::<u16>()?;
    // in the b2b use-case, this is our "own" port, we connect to the "normal" broker node on startup.
    let b2b_port: u16 = std::env::args()
        .nth(3)
        .unwrap_or_else(|| "4242".into())
        .parse::<u16>()?;

    // log::set_logger(..)
    log::set_max_level(log::LevelFilter::Trace);
    println!("Launching in mode {mode} on port {port}");

    match mode.as_str() {
        "broker" => {
            let mut broker = ll_mp::LlmpBroker::new(
                StdShMemProvider::new()?,
                tuple_list!(LlmpExampleHook::new()),
            )?;
            broker.inner_mut().launch_tcp_listener_on(port)?;
            // Exit when we got at least _n_ nodes, and all of them quit.
            broker.set_exit_after(NonZeroUsize::new(1_usize).unwrap());
            broker.loop_with_timeouts(BROKER_TIMEOUT, Some(SLEEP_BETWEEN_FORWARDS));
        }
        "b2b" => {
            let mut broker = ll_mp::LlmpBroker::new(
                StdShMemProvider::new()?,
                tuple_list!(LlmpExampleHook::new()),
            )?;
            broker.inner_mut().launch_tcp_listener_on(b2b_port)?;
            // connect back to the main broker.
            broker.inner_mut().connect_b2b(("127.0.0.1", port))?;
            broker.loop_with_timeouts(BROKER_TIMEOUT, Some(SLEEP_BETWEEN_FORWARDS));
        }
        "ctr" => {
            let mut client =
                ll_mp::LlmpClient::create_attach_to_tcp(StdShMemProvider::new()?, port)?;
            let mut counter: u32 = 0;
            loop {
                counter = counter.wrapping_add(1);
                client.send_buf(_TAG_SIMPLE_U32_V1, &counter.to_le_bytes())?;
                println!("CTR Client writing {counter}");
                thread::sleep(Duration::from_secs(1));
            }
        }
        "adder" => {
            adder_loop(port)?;
        }
        "large" => {
            large_msg_loop(port)?;
        }
        "exiting" => {
            let mut client =
                ll_mp::LlmpClient::create_attach_to_tcp(StdShMemProvider::new()?, port)?;
            for i in 0..10_u32 {
                client.send_buf(_TAG_SIMPLE_U32_V1, &i.to_le_bytes())?;
                println!("Exiting Client writing {i}");
                thread::sleep(Duration::from_millis(10));
            }
            log::info!("Exiting Client exits");
            client.sender_mut().send_exiting()?;

            // there is another way to tell that this client wants to exit.
            // one is to call client.sender_mut().send_exiting()?;
            // you can disconnet the client in this way as long as this client in an unrecoverable state (like in a crash handler)
            // another way to do this is through the detach_from_broker() call
            // you can call detach_from_broker(port); to notify the broker that this broker wants to exit
            // This one is usually for the event restarter to cut off the connection when the client has crashed.
            // In that case we don't have access to the llmp client of the client anymore, but we can use detach_from_broker instead
        }
        _ => {
            println!("No valid mode supplied");
        }
    }
    Ok(())
}

impl<SHM, SP> LlmpSender<SHM, SP>

where SHM: ShMem,

pub fn id(&self) -> ClientId

ID of this sender.

pub unsafe fn reset(&mut self)

Completely reset the current sender map. Afterwards, no receiver should read from it at a different location. This is only useful if all connected llmp parties start over, for example after a crash.

Safety

Only safe if you really really restart the page on everything connected No receiver should read from this page at a different location.

pub unsafe fn to_env(&self, env_name: &str) -> Result<(), Error>

Store the info to this sender to env. A new client can reattach to it using LlmpSender::on_existing_from_env().

Safety

Writes to env variables and may only be done single-threaded.

pub fn await_safe_to_unmap_blocking(&self)

Waits for this sender to be save to unmap. If a receiver is involved, this function should always be called.

pub fn safe_to_unmap(&self) -> bool

If we are allowed to unmap this client

pub unsafe fn mark_safe_to_unmap(&mut self)

For debug purposes: Mark save to unmap, even though it might not have been read by a receiver yet.

Safety

If this method is called, the page may be unmapped before it is read by any receiver.

pub fn describe(&self) -> Result<LlmpDescription, Error>

Describe this LlmpClient in a way that it can be restored later, using Self::on_existing_from_description.

Trait Implementations

impl<SHM: Debug, SP: Debug> Debug for LlmpSender<SHM, SP>

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

Formats the value using the given formatter.