Skip to main content

ibverbs_rs/multi_channel/ops/
polled_ops.rs

1use crate::channel::TransportResult;
2use crate::ibverbs::work::{SendWorkRequest, WorkSuccess};
3use crate::multi_channel::MultiChannel;
4use crate::multi_channel::work_request::*;
5
6impl MultiChannel {
7    /// Posts sends to multiple peers and blocks until all complete.
8    pub fn scatter_send<'op, I>(&'op mut self, wrs: I) -> TransportResult<Vec<WorkSuccess>>
9    where
10        I: IntoIterator<Item = PeerSendWorkRequest<'op, 'op>>,
11    {
12        self.manual_scope(|s| {
13            let wrs = s.post_scatter_send(wrs)?;
14            wrs.into_iter().map(|wr| wr.spin_poll()).collect()
15        })
16    }
17
18    /// Posts RDMA writes to multiple peers and blocks until all complete.
19    pub fn scatter_write<'op, I>(&'op mut self, wrs: I) -> TransportResult<Vec<WorkSuccess>>
20    where
21        I: IntoIterator<Item = PeerWriteWorkRequest<'op, 'op>>,
22    {
23        self.manual_scope(|s| {
24            let wrs = s.post_scatter_write(wrs)?;
25            wrs.into_iter().map(|wr| wr.spin_poll()).collect()
26        })
27    }
28
29    /// Posts receives from multiple peers and blocks until all complete.
30    pub fn gather_receive<'op, I>(&'op mut self, wrs: I) -> TransportResult<Vec<WorkSuccess>>
31    where
32        I: IntoIterator<Item = PeerReceiveWorkRequest<'op, 'op>>,
33    {
34        self.manual_scope(|s| {
35            let wrs = s.post_gather_receive(wrs)?;
36            wrs.into_iter().map(|wr| wr.spin_poll()).collect()
37        })
38    }
39
40    /// Posts RDMA reads from multiple peers and blocks until all complete.
41    pub fn gather_read<'op, I>(&'op mut self, wrs: I) -> TransportResult<Vec<WorkSuccess>>
42    where
43        I: IntoIterator<Item = PeerReadWorkRequest<'op, 'op>>,
44    {
45        self.manual_scope(|s| {
46            let wrs = s.post_gather_read(wrs)?;
47            wrs.into_iter().map(|wr| wr.spin_poll()).collect()
48        })
49    }
50
51    /// Posts the same send to multiple peers and blocks until all complete.
52    pub fn multicast_send<'op, I>(
53        &'op mut self,
54        peers: I,
55        wr: SendWorkRequest<'op, 'op>,
56    ) -> TransportResult<Vec<WorkSuccess>>
57    where
58        I: IntoIterator<Item = usize>,
59    {
60        self.manual_scope(|s| {
61            let wrs = s.post_multicast_send(peers, wr)?;
62            wrs.into_iter().map(|wr| wr.spin_poll()).collect()
63        })
64    }
65}