Struct async_rdma::ManualTrigger

pub struct ManualTrigger(pub Sender<()>);

Manual polling trigger.

Pull this trigger to trigger a polling.

Tuple Fields

0: Sender<()>

Implementations

impl ManualTrigger

pub async fn pull(&self) -> Result<()>

Pull the tirgger to do a polling. Used with get_manual_trigger.

Examples

use async_rdma::{LocalMrReadAccess, LocalMrWriteAccess, RdmaBuilder};
use minstant::Instant;
use portpicker::pick_unused_port;
use std::{
    alloc::Layout,
    io::{self, Write},
    net::{Ipv4Addr, SocketAddrV4},
    time::Duration,
};

async fn client(addr: SocketAddrV4) -> io::Result<()> {
    const POLLING_INTERVAL: Duration = Duration::from_millis(100);
    let rdma = RdmaBuilder::default()
        .set_polling_trigger(async_rdma::PollingTriggerType::Manual)
        .set_cc_evnet_timeout(Duration::from_secs(10))
        .connect(addr)
        .await
        .unwrap();

    let trigger = rdma.get_manual_trigger().unwrap();
    // polling task
    let _trigger_handle = tokio::spawn(async move {
        loop {
            tokio::time::sleep(POLLING_INTERVAL).await;
            trigger.pull().await.unwrap();
        }
    });

    let mut lmr = rdma.alloc_local_mr(Layout::new::<[u8; 8]>())?;
    let _num = lmr.as_mut_slice().write(&[1_u8; 8])?;
    let instant = Instant::now();
    rdma.send(&lmr).await?;
    assert!(instant.elapsed() >= POLLING_INTERVAL);
    Ok(())
}

#[tokio::main]
async fn server(addr: SocketAddrV4) -> io::Result<()> {
    let rdma = RdmaBuilder::default().listen(addr).await?;
    let lmr = rdma.receive().await?;
    let data = *lmr.as_slice();
    assert_eq!(data, [1_u8; 8]);
    Ok(())
}

#[tokio::main]
async fn main() {
    let addr = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), pick_unused_port().unwrap());
    std::thread::spawn(move || server(addr));
    tokio::time::sleep(Duration::from_secs(3)).await;
    client(addr)
        .await
        .map_err(|err| println!("{}", err))
        .unwrap();
}

Trait Implementations

impl Clone for ManualTrigger

fn clone(&self) -> ManualTrigger

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ManualTrigger

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

Formats the value using the given formatter.