ibverbs-rs 0.4.1

Safe, ergonomic Rust bindings for the InfiniBand libibverbs API
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

use crate::channel::TransportResult;
use crate::channel::{PendingWork, PollingScope, ScopedPendingWork};
use crate::ibverbs::error::IbvResult;
use crate::ibverbs::work::WorkSuccess;
use crate::multi_channel::{
    PeerReadWorkRequest, PeerReceiveWorkRequest, PeerSendWorkRequest, PeerWriteWorkRequest,
};
use crate::network::Node;

impl<'scope, 'env> PollingScope<'scope, 'env, Node> {
    /// Posts a send to the work request's target peer, returning a handle for manual polling.
    pub fn post_send(
        &mut self,
        wr: PeerSendWorkRequest<'_, 'env>,
    ) -> TransportResult<ScopedPendingWork<'scope>> {
        Ok(self.channel_post_send(|n| n.multi_channel.channel(wr.peer), wr.wr)?)
    }

    /// Posts a receive to the work request's target peer, returning a handle for manual polling.
    pub fn post_receive(
        &mut self,
        wr: PeerReceiveWorkRequest<'_, 'env>,
    ) -> TransportResult<ScopedPendingWork<'scope>> {
        Ok(self.channel_post_receive(|n| n.multi_channel.channel(wr.peer), wr.wr)?)
    }

    /// Posts an RDMA write to the work request's target peer, returning a handle for manual polling.
    pub fn post_write(
        &mut self,
        wr: PeerWriteWorkRequest<'_, 'env>,
    ) -> TransportResult<ScopedPendingWork<'scope>> {
        Ok(self.channel_post_write(|n| n.multi_channel.channel(wr.peer), wr.wr)?)
    }

    /// Posts an RDMA read to the work request's target peer, returning a handle for manual polling.
    pub fn post_read(
        &mut self,
        wr: PeerReadWorkRequest<'_, 'env>,
    ) -> TransportResult<ScopedPendingWork<'scope>> {
        Ok(self.channel_post_read(|n| n.multi_channel.channel(wr.peer), wr.wr)?)
    }
}

impl Node {
    /// Posts a send to the work request's target peer and blocks until it completes.
    pub fn send<'op>(
        &'op mut self,
        wr: PeerSendWorkRequest<'op, 'op>,
    ) -> TransportResult<WorkSuccess> {
        self.multi_channel.send(wr)
    }

    /// Posts a receive to the work request's target peer and blocks until it completes.
    pub fn receive<'op>(
        &'op mut self,
        wr: PeerReceiveWorkRequest<'op, 'op>,
    ) -> TransportResult<WorkSuccess> {
        self.multi_channel.receive(wr)
    }

    /// Posts an RDMA write to the work request's target peer and blocks until it completes.
    pub fn write<'op>(
        &'op mut self,
        wr: PeerWriteWorkRequest<'op, 'op>,
    ) -> TransportResult<WorkSuccess> {
        self.multi_channel.write(wr)
    }

    /// Posts an RDMA read to the work request's target peer and blocks until it completes.
    pub fn read<'op>(
        &'op mut self,
        wr: PeerReadWorkRequest<'op, 'op>,
    ) -> TransportResult<WorkSuccess> {
        self.multi_channel.read(wr)
    }
}

impl Node {
    /// Posts a send to the target peer without polling for completion.
    ///
    /// # Safety
    /// See [`Channel::send_unpolled`](crate::channel::Channel::send_unpolled).
    pub unsafe fn send_unpolled<'data>(
        &mut self,
        wr: PeerSendWorkRequest<'_, 'data>,
    ) -> IbvResult<PendingWork<'data>> {
        unsafe { self.multi_channel.send_unpolled(wr) }
    }

    /// Posts a receive to the target peer without polling for completion.
    ///
    /// # Safety
    /// See [`Channel::receive_unpolled`](crate::channel::Channel::receive_unpolled).
    pub unsafe fn receive_unpolled<'data>(
        &mut self,
        wr: PeerReceiveWorkRequest<'_, 'data>,
    ) -> IbvResult<PendingWork<'data>> {
        unsafe { self.multi_channel.receive_unpolled(wr) }
    }

    /// Posts an RDMA write to the target peer without polling for completion.
    ///
    /// # Safety
    /// See [`Channel::write_unpolled`](crate::channel::Channel::write_unpolled).
    pub unsafe fn write_unpolled<'data>(
        &mut self,
        wr: PeerWriteWorkRequest<'_, 'data>,
    ) -> IbvResult<PendingWork<'data>> {
        unsafe { self.multi_channel.write_unpolled(wr) }
    }

    /// Posts an RDMA read to the target peer without polling for completion.
    ///
    /// # Safety
    /// See [`Channel::read_unpolled`](crate::channel::Channel::read_unpolled).
    pub unsafe fn read_unpolled<'data>(
        &mut self,
        wr: PeerReadWorkRequest<'_, 'data>,
    ) -> IbvResult<PendingWork<'data>> {
        unsafe { self.multi_channel.read_unpolled(wr) }
    }
}