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::*;
use crate::multi_channel::MultiChannel;
use crate::multi_channel::work_request::{
    PeerReadWorkRequest, PeerReceiveWorkRequest, PeerSendWorkRequest, PeerWriteWorkRequest,
};

impl<'scope, 'env> PollingScope<'scope, 'env, MultiChannel> {
    /// 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(|m| m.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(|m| m.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(|m| m.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(|m| m.channel(wr.peer), wr.wr)?)
    }
}

impl MultiChannel {
    /// 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.channel(wr.peer)?.send(wr.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.channel(wr.peer)?.receive(wr.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.channel(wr.peer)?.write(wr.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.channel(wr.peer)?.read(wr.wr)
    }
}

impl MultiChannel {
    /// 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.channel(wr.peer)?.send_unpolled(wr.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.channel(wr.peer)?.receive_unpolled(wr.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.channel(wr.peer)?.write_unpolled(wr.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.channel(wr.peer)?.read_unpolled(wr.wr) }
    }
}