Struct async_rdma::RdmaBuilder

pub struct RdmaBuilder { /* private fields */ }

The builder for the Rdma, it follows the builder pattern.

Implementations

impl RdmaBuilder

pub fn new() -> Self

Create a default builder The default settings are: dev name: None access right: LocalWrite | RemoteRead | RemoteWrite | RemoteAtomic complete queue size: 16 port number: 1 gid index: 1

Note: We highly recommend setting the port number and the gid index.

pub fn build(&self) -> Result<Rdma>

Create a Rdma from this builder

pub async fn connect<A: ToSocketAddrs>(self, addr: A) -> Result<Rdma>

Establish connection with RDMA server

Used with listen

Examples

use async_rdma::RdmaBuilder;
use portpicker::pick_unused_port;
use std::{
    io,
    net::{Ipv4Addr, SocketAddrV4},
    time::Duration,
};

async fn client(addr: SocketAddrV4) -> io::Result<()> {
    let _rdma = RdmaBuilder::default().connect(addr).await?;
    Ok(())
}

#[tokio::main]
async fn server(addr: SocketAddrV4) -> io::Result<()> {
    let _rdma = RdmaBuilder::default().listen(addr).await?;
    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();
}

pub async fn listen<A: ToSocketAddrs>(self, addr: A) -> Result<Rdma>

Listen to the address to wait for a connection to be established

Used with connect

Examples

use async_rdma::RdmaBuilder;
use portpicker::pick_unused_port;
use std::{
    io,
    net::{Ipv4Addr, SocketAddrV4},
    time::Duration,
};

async fn client(addr: SocketAddrV4) -> io::Result<()> {
    let _rdma = RdmaBuilder::default().connect(addr).await?;
    Ok(())
}

#[tokio::main]
async fn server(addr: SocketAddrV4) -> io::Result<()> {
    let _rdma = RdmaBuilder::default().listen(addr).await?;
    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();
}

pub fn set_dev(self, dev: &str) -> Self

Set device name

pub fn set_cq_size(self, cq_size: u32) -> Self

Set the complete queue size

pub fn set_gid_index(self, gid_index: usize) -> Self

Set the gid index

pub fn set_port_num(self, port_num: u8) -> Self

Set the port number

pub fn set_conn_type(self, conn_type: ConnectionType) -> Self

Set the connection type

pub fn set_raw(self, raw: bool) -> Self

Set if send/recv raw data

pub fn set_qp_max_send_wr(self, max_send_wr: u32) -> Self

Set maximum number of outstanding send requests in the send queue

pub fn set_qp_max_recv_wr(self, max_recv_wr: u32) -> Self

Set maximum number of outstanding receive requests in the receive queue

pub fn set_qp_max_send_sge(self, max_send_sge: u32) -> Self

Set maximum number of scatter/gather elements (SGE) in a WR on the send queue

pub fn set_qp_max_recv_sge(self, max_recv_sge: u32) -> Self

Set maximum number of scatter/gather elements (SGE) in a WR on the receive queue

pub fn set_qp_access(self, flags: BitFlags<AccessFlag>) -> Self

Set default QP access

pub fn set_mr_access(self, flags: BitFlags<AccessFlag>) -> Self

Set default MR access

pub fn set_mr_strategy(self, strategy: MRManageStrategy) -> Self

Set the stragety to manage MRs

pub fn set_max_message_length(self, max_msg_len: usize) -> Self

Set max length of message send/recv by Agent

pub fn set_max_rmr_access(self, flags: BitFlags<AccessFlag>) -> Self

Set max access permission for remote mr requests

Trait Implementations

impl Debug for RdmaBuilder

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

Formats the value using the given formatter.

impl Default for RdmaBuilder

fn default() -> RdmaBuilder

Returns the “default value” for a type.