rrddmma 0.7.3

A Rust library for RDMA.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::{io, mem};

use crate::bindings::*;
use crate::prelude::QpCaps;
use crate::rdma::{context::Context, cq::Cq, mr::Permission, nic::*, pd::Pd, srq::Srq};

use super::{Dct, DctCreationError};

/// DCT builder.
#[derive(Clone, Default)]
pub struct DctBuilder<'a> {
    /// Protection domain of this DCT.
    pub(super) pd: Option<&'a Pd>,

    /// Receive completion queue for this DCT.
    pub(super) cq: Option<&'a Cq>,

    /// The local port to use.
    pub(super) port: Option<Port>,

    /// The GID index to use.
    /// If not specified, use the recommended GID.
    pub(super) gid_index: u8,

    /// The maximum message size (in bytes) that can be inline received by the DCT.
    pub(super) inline_size: u32,
}

impl<'a> DctBuilder<'a> {
    /// Create a new DCT builder.
    pub fn new() -> Self {
        Default::default()
    }

    /// Set the protection domain of this DCT.
    pub fn pd(mut self, pd: &'a Pd) -> Self {
        self.pd = Some(pd);
        self
    }

    /// Set the receive completion queue for this DCT.
    pub fn cq(mut self, cq: &'a Cq) -> Self {
        self.cq = Some(cq);
        self
    }

    /// Set the local port and GID index for this DCT.
    ///
    /// If no GID index is specified (i.e., `gid_index` is `None`), this
    /// method will use the recommended GID. See documentation of
    /// [`Port::recommended_gid()`] for more information.
    pub fn port(mut self, port: &Port, gid_index: Option<u8>) -> Self {
        self.port = Some(port.clone());
        self.gid_index = gid_index.unwrap_or(port.recommended_gid().1);
        self
    }

    /// Set the maximum message size (in bytes) that can be inline received
    /// by this DCT.
    pub fn inline_size(mut self, len: u32) -> Self {
        self.inline_size = len;
        self
    }

    /// Build the DCT.
    ///
    /// # Panics
    ///
    /// Panic if any mandatory field (except `inline_size`) is not set.
    pub fn build(self, context: &Context) -> Result<Dct, DctCreationError> {
        Dct::new(context, self)
    }
}

impl<'a> DctBuilder<'a> {
    /// Unwrap the builder and return the set attributes.
    pub(crate) fn unwrap(self) -> io::Result<DctInitAttr> {
        let pd = self.pd.expect("PD must be set").clone();
        let cq = self.cq.expect("CQ must be set");
        let srq = Srq::new(
            &pd,
            Some(cq),
            QpCaps::default().max_recv_wr,
            QpCaps::default().max_recv_sge,
        )?;
        Ok(DctInitAttr {
            pd,
            cq: cq.clone(),
            srq,
            port: self.port.expect("local port must be set"),
            gid_index: self.gid_index,
            inline_size: self.inline_size,
        })
    }
}

/// Initialization attributes of a DCT endpoint.
pub(crate) struct DctInitAttr {
    /// Protection domain of this DCT.
    pub pd: Pd,

    /// Receive completion queue for this DCT.
    pub cq: Cq,

    /// Receive SRQ for this DCT.
    pub srq: Srq,

    /// Local port that this DCT is bound to.
    pub port: Port,

    /// GID index to use.
    pub gid_index: u8,

    /// The maximum message size (in bytes) that can be inline received by the DCT.
    pub inline_size: u32,
}

impl DctInitAttr {
    /// Create an [`ibv_exp_dct_init_attr`] from the attributes.
    pub fn to_init_attr(&self) -> ibv_exp_dct_init_attr {
        ibv_exp_dct_init_attr {
            pd: self.pd.as_raw(),
            cq: self.cq.as_raw(),
            srq: self.srq.as_raw(),
            dc_key: Dct::GLOBAL_DC_KEY,
            port: self.port.num(),
            access_flags: Permission::default().into(),
            min_rnr_timer: 12,
            mtu: self.port.mtu() as _,
            gid_index: self.gid_index,
            hop_limit: 0xFF,
            inline_size: self.inline_size,

            // SAFETY: POD type.
            ..unsafe { mem::zeroed() }
        }
    }
}