Debian Codegraph @

prov/efa/test/efa_unit_test_pke.c

raw
1 #include "efa_unit_tests.h"
2 #include "rdm/efa_rdm_pke_rtm.h"
3 #include "rdm/efa_rdm_pke_rta.h"
4 #include "rdm/efa_rdm_pke_rtw.h"
5 #include "rdm/efa_rdm_pke_utils.h"
6
7
8 /**
9 * @brief When handling a long cts rtm as read nack fallback,
10 * efa_rdm_pke_handle_longcts_rtm_send_completion shouldn't touch
11 * txe and write send completion.
12 */
13 void test_efa_rdm_pke_handle_longcts_rtm_send_completion(struct efa_resource **state)
14 {
15 struct efa_resource *resource = *state;
16 struct efa_rdm_pke *pkt_entry;
17 struct efa_rdm_ep *efa_rdm_ep;
18 struct efa_rdm_peer *peer;
19 struct fi_msg msg = {0};
20 char buf[16];
21 struct iovec iov = {
22 .iov_base = buf,
23 .iov_len = sizeof buf
24 };
25 struct efa_ep_addr raw_addr = {0};
26 size_t raw_addr_len = sizeof(struct efa_ep_addr);
27 fi_addr_t peer_addr;
28 int err, numaddr;
29 struct efa_rdm_ope *txe;
30
31 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
32
33 efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid);
34
35 /* create a fake peer */
36 err = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len);
37 assert_int_equal(err, 0);
38 raw_addr.qpn = 1;
39 raw_addr.qkey = 0x1234;
40 numaddr = fi_av_insert(resource->av, &raw_addr, 1, &peer_addr, 0, NULL);
41 assert_int_equal(numaddr, 1);
42 peer = efa_rdm_ep_get_peer(efa_rdm_ep, peer_addr);
43 assert_non_null(peer);
44
45 /* Construct a txe with read nack flag added */
46 msg.addr = peer_addr;
47 msg.iov_count = 1;
48 msg.msg_iov = &iov;
49 msg.desc = NULL;
50 txe = efa_rdm_ep_alloc_txe(efa_rdm_ep, peer, &msg, ofi_op_msg, 0, 0);
51 assert_non_null(txe);
52 txe->internal_flags |= EFA_RDM_OPE_READ_NACK;
53
54 /* construct a fallback long cts rtm pkt */
55 pkt_entry = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_tx_pkt_pool, EFA_RDM_PKE_FROM_EFA_TX_POOL);
56 assert_non_null(pkt_entry);
57
58 err = efa_rdm_pke_init_longcts_msgrtm(pkt_entry, txe);
59 assert_int_equal(err, 0);
60
61 assert_int_equal(pkt_entry->payload_size, 0);
62
63 /* Mimic the case when CTSDATA pkts have completed all data and released the txe */
64 txe->bytes_acked = txe->total_len;
65 txe->bytes_sent = txe->total_len;
66 efa_rdm_txe_release(txe);
67
68 efa_rdm_pke_handle_longcts_rtm_send_completion(pkt_entry);
69
70 /* CQ should be empty as send completion shouldn't be written */
71 assert_int_equal(fi_cq_read(resource->cq, NULL, 1), -FI_EAGAIN);
72
73 efa_rdm_pke_release_tx(pkt_entry);
74 }
75
76 /**
77 * @brief Test the efa_rdm_pke_release_rx_list function
78 *
79 * @param state
80 */
81 void test_efa_rdm_pke_release_rx_list(struct efa_resource **state)
82 {
83 struct efa_resource *resource = *state;
84 struct efa_rdm_ep *efa_rdm_ep;
85 struct efa_rdm_pke *pke, *curr;
86 int i;
87
88 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
89
90 efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid);
91
92 /* Fake a rx pkt entry */
93 pke = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_rx_pkt_pool, EFA_RDM_PKE_FROM_EFA_RX_POOL);
94 assert_non_null(pke);
95 efa_rdm_ep->efa_rx_pkts_posted = efa_rdm_ep_get_rx_pool_size(efa_rdm_ep);
96
97 /* link multiple pkes to this pke */
98 for (i = 1; i < 10; i++) {
99 curr = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_rx_pkt_pool, EFA_RDM_PKE_FROM_EFA_RX_POOL);
100 assert_non_null(curr);
101 efa_rdm_pke_append(pke, curr);
102 }
103
104 /* Release all entries in the linked list */
105 efa_rdm_pke_release_rx_list(pke);
106
107 /**
108 * Now the rx pkt buffer pool should be empty so we can destroy it
109 * Otherwise there will be an assertion error on the use cnt is
110 * is non-zero
111 */
112 ofi_bufpool_destroy(efa_rdm_ep->efa_rx_pkt_pool);
113 efa_rdm_ep->efa_rx_pkt_pool = NULL;
114 }
115
116 void test_efa_rdm_pke_alloc_rta_rxe(struct efa_resource **state)
117 {
118 struct efa_resource *resource = *state;
119 struct efa_rdm_ep *efa_rdm_ep;
120 struct efa_rdm_pke *pke;
121 struct efa_rdm_ope *rxe;
122 struct efa_ep_addr raw_addr = {0};
123 size_t raw_addr_len = sizeof(raw_addr);
124 fi_addr_t peer_addr = 0;
125
126 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
127
128 efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep,
129 base_ep.util_ep.ep_fid);
130
131 /* Fake a rx pkt entry */
132 pke = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_rx_pkt_pool,
133 EFA_RDM_PKE_FROM_EFA_RX_POOL);
134 assert_non_null(pke);
135 efa_rdm_ep->efa_rx_pkts_posted =
136 efa_rdm_ep_get_rx_pool_size(efa_rdm_ep);
137
138 /* Create and register a fake peer */
139 assert_int_equal(
140 fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len), 0);
141 raw_addr.qpn = 0;
142 raw_addr.qkey = 0x1234;
143 assert_int_equal(
144 fi_av_insert(resource->av, &raw_addr, 1, &peer_addr, 0, NULL),
145 1);
146
147 pke->addr = peer_addr;
148
149 rxe = efa_rdm_pke_alloc_rta_rxe(pke, ofi_op_atomic);
150 assert_true(rxe->internal_flags & EFA_RDM_OPE_INTERNAL);
151
152 efa_rdm_rxe_release(rxe);
153 efa_rdm_pke_release_rx(pke);
154 }
155
156 void test_efa_rdm_pke_alloc_rtw_rxe(struct efa_resource **state)
157 {
158 struct efa_resource *resource = *state;
159 struct efa_rdm_ep *efa_rdm_ep;
160 struct efa_rdm_pke *pke;
161 struct efa_rdm_ope *rxe;
162 struct efa_ep_addr raw_addr = {0};
163 size_t raw_addr_len = sizeof(raw_addr);
164 fi_addr_t peer_addr = 0;
165 struct efa_rdm_base_hdr *base_hdr;
166
167 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
168
169 efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep,
170 base_ep.util_ep.ep_fid);
171
172 /* Fake a rx pkt entry */
173 pke = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_rx_pkt_pool,
174 EFA_RDM_PKE_FROM_EFA_RX_POOL);
175 assert_non_null(pke);
176 efa_rdm_ep->efa_rx_pkts_posted =
177 efa_rdm_ep_get_rx_pool_size(efa_rdm_ep);
178
179 /* Create and register a fake peer */
180 assert_int_equal(
181 fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len), 0);
182 raw_addr.qpn = 0;
183 raw_addr.qkey = 0x1234;
184 assert_int_equal(
185 fi_av_insert(resource->av, &raw_addr, 1, &peer_addr, 0, NULL),
186 1);
187
188 base_hdr = efa_rdm_pke_get_base_hdr(pke);
189 /* Clean the flags to avoid having garbage value */
190 base_hdr->flags = 0;
191 pke->addr = peer_addr;
192
193 rxe = efa_rdm_pke_alloc_rtw_rxe(pke);
194
195 assert_true(rxe->internal_flags & EFA_RDM_OPE_INTERNAL);
196 assert_int_equal(rxe->bytes_received, 0);
197 assert_int_equal(rxe->bytes_copied, 0);
198
199 efa_rdm_rxe_release(rxe);
200 efa_rdm_pke_release_rx(pke);
201 }
202
203 void test_efa_rdm_pke_alloc_rtr_rxe(struct efa_resource **state)
204 {
205 struct efa_resource *resource = *state;
206 struct efa_rdm_ep *efa_rdm_ep;
207 struct efa_rdm_pke *pke;
208 struct efa_rdm_ope *rxe;
209 struct efa_ep_addr raw_addr = {0};
210 size_t raw_addr_len = sizeof(raw_addr);
211 fi_addr_t peer_addr = 0;
212 struct efa_rdm_base_hdr *base_hdr;
213
214 efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
215
216 efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep,
217 base_ep.util_ep.ep_fid);
218
219 /* Fake a rx pkt entry */
220 pke = efa_rdm_pke_alloc(efa_rdm_ep, efa_rdm_ep->efa_rx_pkt_pool,
221 EFA_RDM_PKE_FROM_EFA_RX_POOL);
222 assert_non_null(pke);
223 efa_rdm_ep->efa_rx_pkts_posted =
224 efa_rdm_ep_get_rx_pool_size(efa_rdm_ep);
225
226 /* Create and register a fake peer */
227 assert_int_equal(
228 fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len), 0);
229 raw_addr.qpn = 0;
230 raw_addr.qkey = 0x1234;
231 assert_int_equal(
232 fi_av_insert(resource->av, &raw_addr, 1, &peer_addr, 0, NULL),
233 1);
234
235 base_hdr = efa_rdm_pke_get_base_hdr(pke);
236 /* Clean the flags to avoid having garbage value */
237 base_hdr->flags = 0;
238 pke->addr = peer_addr;
239
240 rxe = efa_rdm_pke_alloc_rtw_rxe(pke);
241
242 assert_true(rxe->internal_flags & EFA_RDM_OPE_INTERNAL);
243 assert_int_equal(rxe->bytes_received, 0);
244 assert_int_equal(rxe->bytes_copied, 0);
245
246 efa_rdm_rxe_release(rxe);
247 efa_rdm_pke_release_rx(pke);
248 }