Debian Codegraph @

prov/efa/test/efa_unit_test_rdm_peer.c

raw
1 /* SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0-only */
2 /* SPDX-FileCopyrightText: Copyright Amazon.com, Inc. or its affiliates. All rights reserved. */
3
4 #include "efa_unit_tests.h"
5
6 /**
7 * @brief Test efa_rdm_peer_reorder_msg
8 *
9 * @param resource efa_resource
10 * @param exp_msg_id expected message id of receive window
11 * @param msg_id received message id
12 * @param expected_ret expected return value of efa_rdm_peer_reorder_msg
13 */
14 void test_efa_rdm_peer_reorder_msg_impl(struct efa_resource *resource,
15 uint32_t exp_msg_id, uint32_t msg_id,
16 int expected_ret)
17 {
18 struct efa_rdm_ep *efa_rdm_ep;
19 struct efa_rdm_peer *peer;
20 struct efa_ep_addr raw_addr;
21 fi_addr_t addr;
22 struct efa_unit_test_eager_rtm_pkt_attr pkt_attr = {0};
23 size_t raw_addr_len = sizeof(raw_addr);
24 struct efa_rdm_peer_overflow_pke_list_entry *overflow_pke_list_entry;
25 struct efa_rdm_pke *pkt_entry, *overflow_pkt_entry;
26 struct dlist_entry *tmp;
27 uint32_t overflow_msg_id;
28 int ret;
29
30 efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep,
31 base_ep.util_ep.ep_fid);
32
33 /* Create and register a fake peer */
34 ret = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len);
35 assert_int_equal(ret, 0);
36 raw_addr.qpn = 1;
37 raw_addr.qkey = 0x1234;
38 ret = fi_av_insert(resource->av, &raw_addr, 1, &addr, 0 /* flags */, NULL /* context */);
39 assert_int_equal(ret, 1);
40 peer = efa_rdm_ep_get_peer(efa_rdm_ep, addr);
41 assert_non_null(peer);
42
43 pkt_entry = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_rx_pkt_pool,
44 EFA_RDM_PKE_FROM_EFA_RX_POOL);
45 assert_non_null(pkt_entry);
46 efa_rdm_ep->efa_rx_pkts_posted = efa_rdm_ep_get_rx_pool_size(efa_rdm_ep);
47
48 pkt_attr.msg_id = msg_id;
49 pkt_attr.connid = raw_addr.qkey;
50 /* Packet type must be >= EFA_RDM_REQ_PKT_BEGIN */
51 efa_unit_test_eager_msgrtm_pkt_construct(pkt_entry, &pkt_attr);
52
53 (&peer->robuf)->exp_msg_id = exp_msg_id;
54 ret = efa_rdm_peer_reorder_msg(peer, efa_rdm_ep, pkt_entry);
55 assert_int_equal(ret, expected_ret);
56 (&peer->robuf)->exp_msg_id = 0;
57
58 if (!ofi_recvwin_id_valid((&peer->robuf), msg_id) &&
59 !ofi_recvwin_id_processed((&peer->robuf), msg_id)) {
60 /* Check the overflow_pke_list contains the overflow msg_id */
61 assert_int_equal(efa_unit_test_get_dlist_length(&peer->overflow_pke_list), 1);
62 dlist_foreach_container_safe (
63 &peer->overflow_pke_list,
64 struct efa_rdm_peer_overflow_pke_list_entry,
65 overflow_pke_list_entry, entry, tmp) {
66 overflow_pkt_entry = overflow_pke_list_entry->pkt_entry;
67 overflow_msg_id = ((struct efa_rdm_rtm_base_hdr *) overflow_pkt_entry->wiredata)->msg_id;
68 assert_int_equal(overflow_msg_id, msg_id);
69 /* Clean up */
70 dlist_remove(&overflow_pke_list_entry->entry);
71 efa_rdm_pke_release_rx(overflow_pke_list_entry->pkt_entry);
72 ofi_buf_free(overflow_pke_list_entry);
73 }
74 } else {
75 efa_rdm_pke_release_rx(pkt_entry);
76 }
77 }
78
79 void test_efa_rdm_peer_reorder_expected_msg_id(struct efa_resource **state) {
80 struct efa_resource *resource = *state;
81 uint32_t msg_id, exp_msg_id;
82 int expected_ret;
83
84 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
85
86 msg_id = 0;
87 exp_msg_id = 0;
88 expected_ret = 0;
89 /* Receiving expected message id should return 0 */
90 test_efa_rdm_peer_reorder_msg_impl(resource, exp_msg_id, msg_id, expected_ret);
91 }
92
93
94 void test_efa_rdm_peer_reorder_smaller_msg_id(struct efa_resource **state) {
95 struct efa_resource *resource = *state;
96 uint32_t msg_id, exp_msg_id;
97 int expected_ret;
98
99 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
100
101 msg_id = 1;
102 exp_msg_id = 10;
103 expected_ret = -FI_EALREADY;
104 /* Receiving message id smaller than expected should return -FI_EALREADY */
105 test_efa_rdm_peer_reorder_msg_impl(resource, exp_msg_id, msg_id, expected_ret);
106 }
107
108 void test_efa_rdm_peer_reorder_larger_msg_id(struct efa_resource **state) {
109 struct efa_resource *resource = *state;
110 uint32_t msg_id, exp_msg_id;
111 int expected_ret;
112
113 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
114
115 msg_id = 10;
116 exp_msg_id = 0;
117 expected_ret = 1;
118 efa_env.rx_copy_ooo = 0; /* Do not copy this pkt entry */
119 /* Receiving message id larger than expected should return 1 */
120 test_efa_rdm_peer_reorder_msg_impl(resource, exp_msg_id, msg_id, expected_ret);
121 }
122
123 void test_efa_rdm_peer_reorder_overflow_msg_id(struct efa_resource **state) {
124 struct efa_resource *resource = *state;
125 uint32_t msg_id, exp_msg_id;
126 int expected_ret;
127
128 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
129
130 msg_id = 16384;
131 exp_msg_id = 0;
132 expected_ret = 1;
133 /* Message id that overflows the receive window should be put in the
134 * overflow_pke_list and return 1 */
135 test_efa_rdm_peer_reorder_msg_impl(resource, exp_msg_id, msg_id, expected_ret);
136 }
137
138 /**
139 * @brief Test efa_rdm_peer_move_overflow_pke_to_recvwin
140 *
141 * @param resource efa_resource
142 * @param msg_id received message id
143 * @param peer efa_rdm_peer
144 * @param pkt_entry packet entry in the overflow list
145 */
146 void test_efa_rdm_peer_move_overflow_pke_to_recvwin_impl(
147 struct efa_resource *resource, uint32_t msg_id,
148 struct efa_rdm_peer **peer, struct efa_rdm_pke **pkt_entry)
149 {
150 struct efa_rdm_ep *efa_rdm_ep;
151 struct efa_ep_addr raw_addr;
152 fi_addr_t addr;
153 struct efa_unit_test_eager_rtm_pkt_attr pkt_attr = {0};
154 size_t raw_addr_len = sizeof(raw_addr);
155 struct efa_rdm_peer_overflow_pke_list_entry *overflow_pke_list_entry;
156 int ret;
157
158 efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep,
159 base_ep.util_ep.ep_fid);
160
161 /* Create and register a fake peer */
162 ret = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len);
163 assert_int_equal(ret, 0);
164 raw_addr.qpn = 1;
165 raw_addr.qkey = 0x1234;
166 ret = fi_av_insert(resource->av, &raw_addr, 1, &addr, 0 /* flags */, NULL /* context */);
167 assert_int_equal(ret, 1);
168 *peer = efa_rdm_ep_get_peer(efa_rdm_ep, addr);
169 assert_non_null(*peer);
170
171 *pkt_entry = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_rx_pkt_pool,
172 EFA_RDM_PKE_FROM_EFA_RX_POOL);
173 assert_non_null(*pkt_entry);
174 efa_rdm_ep->efa_rx_pkts_posted = efa_rdm_ep_get_rx_pool_size(efa_rdm_ep);
175
176 pkt_attr.msg_id = msg_id;
177 pkt_attr.connid = raw_addr.qkey;
178 /* Packet type must be >= EFA_RDM_REQ_PKT_BEGIN */
179 efa_unit_test_eager_msgrtm_pkt_construct(*pkt_entry, &pkt_attr);
180
181 overflow_pke_list_entry = ofi_buf_alloc(efa_rdm_ep->overflow_pke_pool);
182 overflow_pke_list_entry->pkt_entry = *pkt_entry;
183 dlist_insert_head(&overflow_pke_list_entry->entry, &(*peer)->overflow_pke_list);
184
185 (&(*peer)->robuf)->exp_msg_id = efa_env.recvwin_size;
186 efa_env.rx_copy_ooo = 0;
187 efa_rdm_peer_move_overflow_pke_to_recvwin(*peer);
188 }
189
190 void test_efa_rdm_peer_move_overflow_pke_to_recvwin(struct efa_resource **state) {
191 struct efa_resource *resource = *state;
192 struct efa_rdm_peer *peer;
193 struct efa_rdm_pke *pkt_entry;
194
195 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
196
197 /* overflow_pke_list has a pkt entry with msg_id 18000.
198 * After calling efa_rdm_peer_move_overflow_pke_to_recvwin when exp_msg_id = 16384,
199 * 18000 will be moved to recvwin and overflow_pke_list will be empty. */
200 test_efa_rdm_peer_move_overflow_pke_to_recvwin_impl(
201 resource, 18000, &peer, &pkt_entry);
202
203 assert_non_null(*ofi_recvwin_get_msg((&peer->robuf), 18000));
204 assert_int_equal(efa_unit_test_get_dlist_length(&peer->overflow_pke_list), 0);
205
206 efa_rdm_pke_release_rx(pkt_entry);
207 }
208
209 void test_efa_rdm_peer_keep_pke_in_overflow_list(struct efa_resource **state) {
210 struct efa_resource *resource = *state;
211 struct efa_rdm_peer *peer;
212 struct efa_rdm_pke *pkt_entry;
213 struct efa_rdm_peer_overflow_pke_list_entry *overflow_pke_list_entry;
214 struct dlist_entry *tmp;
215
216 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
217
218 /* overflow_pke_list has a pkt entry with msg_id 33000.
219 * After calling efa_rdm_peer_move_overflow_pke_to_recvwin when exp_msg_id = 16384,
220 * 33000 will stay in overflow_pke_list. */
221 test_efa_rdm_peer_move_overflow_pke_to_recvwin_impl(
222 resource, 33000, &peer, &pkt_entry);
223
224 assert_int_equal(efa_unit_test_get_dlist_length(&peer->overflow_pke_list), 1);
225
226 dlist_foreach_container_safe (
227 &peer->overflow_pke_list,
228 struct efa_rdm_peer_overflow_pke_list_entry,
229 overflow_pke_list_entry, entry, tmp) {
230 dlist_remove(&overflow_pke_list_entry->entry);
231 efa_rdm_pke_release_rx(overflow_pke_list_entry->pkt_entry);
232 ofi_buf_free(overflow_pke_list_entry);
233 }
234 }
235
236 void alloc_pke_in_overflow_list(struct efa_rdm_ep *efa_rdm_ep,
237 struct efa_rdm_pke **pkt_entry, struct efa_rdm_peer *peer,
238 struct efa_ep_addr raw_addr, uint32_t msg_id)
239 {
240 struct efa_unit_test_eager_rtm_pkt_attr pkt_attr = {0};
241 struct efa_rdm_peer_overflow_pke_list_entry *overflow_pke_list_entry;
242 struct efa_rdm_rtm_base_hdr *rtm_hdr;
243
244 *pkt_entry = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_rx_pkt_pool,
245 EFA_RDM_PKE_FROM_EFA_RX_POOL);
246 assert_non_null(*pkt_entry);
247 efa_rdm_ep->efa_rx_pkts_posted = efa_rdm_ep_get_rx_pool_size(efa_rdm_ep);
248
249 pkt_attr.msg_id = msg_id;
250 pkt_attr.connid = raw_addr.qkey;
251 /* Packet type must be >= EFA_RDM_REQ_PKT_BEGIN */
252 efa_unit_test_eager_msgrtm_pkt_construct(*pkt_entry, &pkt_attr);
253 rtm_hdr = (struct efa_rdm_rtm_base_hdr *) (*pkt_entry)->wiredata;
254 rtm_hdr->type = EFA_RDM_MEDIUM_TAGRTM_PKT;
255 rtm_hdr->flags |= EFA_RDM_REQ_MSG;
256
257 overflow_pke_list_entry = ofi_buf_alloc(efa_rdm_ep->overflow_pke_pool);
258 overflow_pke_list_entry->pkt_entry = *pkt_entry;
259 dlist_insert_head(&overflow_pke_list_entry->entry, &peer->overflow_pke_list);
260 }
261
262 void test_efa_rdm_peer_append_overflow_pke_to_recvwin(struct efa_resource **state) {
263 struct efa_resource *resource = *state;
264 struct efa_rdm_peer *peer;
265 struct efa_rdm_pke *pkt_entry1, *pkt_entry2;
266 struct efa_ep_addr raw_addr;
267 fi_addr_t addr;
268 size_t raw_addr_len = sizeof(raw_addr);
269 struct efa_rdm_ep *efa_rdm_ep;
270 int ret;
271
272 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
273
274 efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep,
275 base_ep.util_ep.ep_fid);
276
277 /* Create and register a fake peer */
278 ret = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len);
279 assert_int_equal(ret, 0);
280 raw_addr.qpn = 1;
281 raw_addr.qkey = 0x1234;
282 ret = fi_av_insert(resource->av, &raw_addr, 1, &addr, 0 /* flags */, NULL /* context */);
283 assert_int_equal(ret, 1);
284 peer = efa_rdm_ep_get_peer(efa_rdm_ep, addr);
285 assert_non_null(peer);
286
287 alloc_pke_in_overflow_list(efa_rdm_ep, &pkt_entry2, peer, raw_addr, 17000);
288 alloc_pke_in_overflow_list(efa_rdm_ep, &pkt_entry1, peer, raw_addr, 17000);
289 assert_int_equal(efa_unit_test_get_dlist_length(&peer->overflow_pke_list), 2);
290
291 /* overflow_pke_list has two pkt entries with msg_id 17000.
292 * After calling efa_rdm_peer_move_overflow_pke_to_recvwin when exp_msg_id = 16384,
293 * two pkt entries of same msg id will be appended to the same entry in recvwin,
294 * and overflow_pke_list will be empty. */
295 (&peer->robuf)->exp_msg_id = efa_env.recvwin_size;
296 efa_env.rx_copy_ooo = 0;
297 efa_rdm_peer_move_overflow_pke_to_recvwin(peer);
298
299 pkt_entry1 = *ofi_recvwin_get_msg((&peer->robuf), 17000);
300 assert_non_null(pkt_entry1);
301 assert_non_null(pkt_entry1->next);
302 assert_int_equal(efa_unit_test_get_dlist_length(&peer->overflow_pke_list), 0);
303 assert(pkt_entry1->next == pkt_entry2);
304
305 efa_rdm_pke_release_rx(pkt_entry1->next);
306 pkt_entry1->next = NULL;
307 efa_rdm_pke_release_rx(pkt_entry1);
308 }