Debian Codegraph @

tests/test_odp.py

raw
1 from pyverbs.mem_alloc import mmap, munmap, madvise, MAP_ANONYMOUS_, MAP_PRIVATE_, \
2 MAP_HUGETLB_
3 from pyverbs.pyverbs_error import PyverbsError, PyverbsRDMAError
4 from tests.base import RCResources, UDResources, XRCResources
5 from pyverbs.qp import QPCap, QPAttr, QPInitAttr
6 from pyverbs.wr import SGE, SendWR, RecvWR
7 from tests.base import RDMATestCase
8 from pyverbs.mr import MR, MREx
9 from pyverbs.libibverbs_enums import ibv_odp_transport_cap_bits, ibv_access_flags, ibv_odp_transport_cap_bits, \
10 ibv_qp_type, ibv_placement_type, ibv_selectivity_level, ibv_qp_create_send_ops_flags, ibv_wr_opcode, \
11 ibv_wc_status, _IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE, _IBV_ADVISE_MR_ADVICE_PREFETCH, \
12 _IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT
13 import tests.utils as u
14 import unittest
15 import errno
16
17
18 HUGE_PAGE_SIZE = 0x200000
19
20
21 class OdpUD(UDResources):
22 def __init__(self, request_user_addr=False, **kwargs):
23 self.request_user_addr = request_user_addr
24 self.user_addr = None
25 super(OdpUD, self).__init__(**kwargs)
26
27 @u.requires_odp('ud', ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_SEND)
28 def create_mr(self):
29 if self.request_user_addr:
30 self.user_addr = mmap(length=self.msg_size,
31 flags=MAP_ANONYMOUS_ | MAP_PRIVATE_)
32 self.send_mr = MR(self.pd, self.msg_size + u.GRH_SIZE,
33 ibv_access_flags.IBV_ACCESS_LOCAL_WRITE | ibv_access_flags.IBV_ACCESS_ON_DEMAND,
34 address=self.user_addr)
35 self.recv_mr = MR(self.pd, self.msg_size + u.GRH_SIZE,
36 ibv_access_flags.IBV_ACCESS_LOCAL_WRITE)
37
38
39 class OdpRC(RCResources):
40 def __init__(self, dev_name, ib_port, gid_index, is_huge=False,
41 request_user_addr=False, use_mr_prefetch=None, is_implicit=False,
42 prefetch_advice=_IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE,
43 msg_size=1024,
44 odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_SEND | ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_RECV,
45 use_mixed_mr=False):
46 """
47 Initialize an OdpRC object.
48 :param dev_name: Device name to be used
49 :param ib_port: IB port of the device to use
50 :param gid_index: Which GID index to use
51 :param is_huge: If True, use huge pages for MR registration
52 :param request_user_addr: Request to provide the MR's buffer address.
53 If False, the buffer will be allocated by pyverbs.
54 :param use_mr_prefetch: Describes the properties of the prefetch
55 operation. The options are 'sync', 'async'
56 and None to skip the prefetch operation.
57 :param is_implicit: If True, register implicit MR.
58 :param prefetch_advice: The advice of the prefetch request (ignored
59 if use_mr_prefetch is None).
60 :param use_mixed_mr: If True, create a non-ODP MR in addition to the ODP MR.
61 """
62 self.is_huge = is_huge
63 self.request_user_addr = request_user_addr
64 self.is_implicit = is_implicit
65 self.odp_caps = odp_caps
66 self.access = ibv_access_flags.IBV_ACCESS_LOCAL_WRITE | ibv_access_flags.IBV_ACCESS_ON_DEMAND | \
67 ibv_access_flags.IBV_ACCESS_REMOTE_ATOMIC | ibv_access_flags.IBV_ACCESS_REMOTE_READ | \
68 ibv_access_flags.IBV_ACCESS_REMOTE_WRITE
69 self.user_addr = None
70 self.use_mixed_mr = use_mixed_mr
71 self.non_odp_mr = None
72 super(OdpRC, self).__init__(dev_name=dev_name, ib_port=ib_port,
73 gid_index=gid_index)
74 self.use_mr_prefetch = use_mr_prefetch
75 self.prefetch_advice = prefetch_advice
76 self.msg_size = msg_size
77
78 @u.requires_odp('rc', ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_SEND | ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_RECV)
79 def create_mr(self):
80 u.odp_supported(self.ctx, 'rc', self.odp_caps)
81 if self.request_user_addr:
82 mmap_flags = MAP_ANONYMOUS_| MAP_PRIVATE_
83 length = self.msg_size
84 if self.is_huge:
85 mmap_flags |= MAP_HUGETLB_
86 length = HUGE_PAGE_SIZE
87 self.user_addr = mmap(length=length, flags=mmap_flags)
88 access = self.access
89 if self.is_huge:
90 access |= ibv_access_flags.IBV_ACCESS_HUGETLB
91 self.mr = MR(self.pd, self.msg_size, access, address=self.user_addr,
92 implicit=self.is_implicit)
93 if self.use_mixed_mr:
94 self.non_odp_mr = MR(self.pd, self.msg_size, ibv_access_flags.IBV_ACCESS_LOCAL_WRITE)
95
96 def create_qp_init_attr(self):
97 return QPInitAttr(qp_type=ibv_qp_type.IBV_QPT_RC, scq=self.cq, sq_sig_all=0,
98 rcq=self.cq, srq=self.srq, cap=self.create_qp_cap())
99
100 def create_qp_attr(self):
101 qp_attr = QPAttr(port_num=self.ib_port)
102 qp_attr.qp_access_flags = self.access
103 return qp_attr
104
105 def create_qp_cap(self):
106 if self.use_mixed_mr:
107 return QPCap(max_recv_wr=self.num_msgs, max_send_sge=2, max_recv_sge=2)
108 return super().create_qp_cap()
109
110
111 class OdpXRC(XRCResources):
112 def __init__(self, request_user_addr=False, **kwargs):
113 self.request_user_addr = request_user_addr
114 self.user_addr = None
115 super(OdpXRC, self).__init__(**kwargs)
116
117 @u.requires_odp('xrc', ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_SEND | ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_SRQ_RECV)
118 def create_mr(self):
119 if self.request_user_addr:
120 self.user_addr = mmap(length=self.msg_size,
121 flags=MAP_ANONYMOUS_| MAP_PRIVATE_)
122 self.mr = u.create_custom_mr(self, ibv_access_flags.IBV_ACCESS_ON_DEMAND, user_addr=self.user_addr)
123
124 class OdpQpExRC(RCResources):
125 def __init__(self, dev_name, ib_port, gid_index, is_huge=False,
126 request_user_addr=False, use_mr_prefetch=None, is_implicit=False,
127 prefetch_advice=_IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE,
128 msg_size=8,
129 odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_SEND | ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_RECV,
130 use_mixed_mr=False):
131
132 ''' For object descriptions, refer to OdpRC class '''
133 self.request_user_addr = request_user_addr
134 self.is_implicit = is_implicit
135 self.odp_caps = odp_caps
136 self.access = ibv_access_flags.IBV_ACCESS_LOCAL_WRITE | ibv_access_flags.IBV_ACCESS_ON_DEMAND | \
137 ibv_access_flags.IBV_ACCESS_REMOTE_ATOMIC | ibv_access_flags.IBV_ACCESS_REMOTE_READ | \
138 ibv_access_flags.IBV_ACCESS_REMOTE_WRITE
139 self.user_addr = None
140 super(OdpQpExRC, self).__init__(dev_name=dev_name, ib_port=ib_port,
141 gid_index=gid_index)
142 self.msg_size = msg_size
143
144 if self.odp_caps & ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_FLUSH:
145 self.ptype = ibv_placement_type.IBV_FLUSH_GLOBAL
146 self.level = ibv_selectivity_level.IBV_FLUSH_RANGE
147
148 def create_qps(self):
149 if self.odp_caps & ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_ATOMIC_WRITE:
150 u.create_qp_ex(self, ibv_qp_type.IBV_QPT_RC, ibv_qp_create_send_ops_flags.IBV_QP_EX_WITH_ATOMIC_WRITE)
151 elif self.odp_caps & ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_FLUSH:
152 u.create_qp_ex(self, ibv_qp_type.IBV_QPT_RC,
153 ibv_qp_create_send_ops_flags.IBV_QP_EX_WITH_FLUSH | \
154 ibv_qp_create_send_ops_flags.IBV_QP_EX_WITH_RDMA_WRITE)
155 else:
156 raise unittest.SkipTest('There is no qpex test for the specified ODP caps.')
157
158 def create_mr(self):
159 u.odp_supported(self.ctx, 'rc', self.odp_caps)
160 if self.odp_caps & ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_ATOMIC_WRITE:
161 access = self.access
162 if self.request_user_addr:
163 mmap_flags = MAP_ANONYMOUS_| MAP_PRIVATE_
164 length = self.msg_size
165 self.user_addr = mmap(length=length, flags=mmap_flags)
166 self.mr = MR(self.pd, self.msg_size, access, address=self.user_addr,
167 implicit=self.is_implicit)
168 elif self.odp_caps & ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_FLUSH:
169 try:
170 self.mr = u.create_custom_mr(self, ibv_access_flags.IBV_ACCESS_FLUSH_GLOBAL | \
171 ibv_access_flags.IBV_ACCESS_REMOTE_WRITE | \
172 ibv_access_flags.IBV_ACCESS_ON_DEMAND)
173 except PyverbsRDMAError as ex:
174 if ex.error_code == errno.EINVAL:
175 raise unittest.SkipTest('Create mr with IBV_ACCESS_FLUSH_GLOBAL access flag is not supported in kernel')
176 raise ex
177 else:
178 raise unittest.SkipTest('There is no qpex test for the specified ODP caps.')
179
180
181 class OdpQpExMRExRC(OdpQpExRC):
182 """
183 MREx version of OdpQpExRC that uses MREx instead of MR for memory registration.
184 """
185 def create_mr(self):
186 u.odp_supported(self.ctx, 'rc', self.odp_caps)
187 if self.odp_caps & ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_FLUSH:
188 try:
189 self.mr = u.create_custom_mr(self, ibv_access_flags.IBV_ACCESS_FLUSH_GLOBAL |
190 ibv_access_flags.IBV_ACCESS_REMOTE_WRITE |
191 ibv_access_flags.IBV_ACCESS_ON_DEMAND,
192 mr_ex=True)
193 except PyverbsRDMAError as ex:
194 if ex.error_code == errno.EINVAL:
195 raise unittest.SkipTest('Create mr with IBV_ACCESS_FLUSH_GLOBAL access flag is'
196 ' not supported in kernel')
197 raise ex
198 else:
199 raise unittest.SkipTest('There is no qpex test for the specified ODP caps.')
200
201
202 class MRExOdpRC(OdpRC):
203 """
204 MREx version of OdpRC that uses MREx instead of MR for memory registration.
205 """
206 @u.requires_odp('rc', ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_SEND |
207 ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_RECV)
208 @u.skip_unsupported
209 def create_mr(self):
210 u.odp_supported(self.ctx, 'rc', self.odp_caps)
211 if self.request_user_addr:
212 mmap_flags = MAP_ANONYMOUS_| MAP_PRIVATE_
213 length = self.msg_size
214 if self.is_huge:
215 mmap_flags |= MAP_HUGETLB_
216 length = HUGE_PAGE_SIZE
217 self.user_addr = mmap(length=length, flags=mmap_flags)
218 access = self.access
219 if self.is_huge:
220 access |= ibv_access_flags.IBV_ACCESS_HUGETLB
221 self.mr = MREx(self.pd, self.msg_size, access, address=self.user_addr,
222 implicit=self.is_implicit)
223 if self.use_mixed_mr:
224 self.non_odp_mr = MREx(self.pd, self.msg_size, ibv_access_flags.IBV_ACCESS_LOCAL_WRITE)
225
226
227 class OdpTestCase(RDMATestCase):
228 def setUp(self):
229 super(OdpTestCase, self).setUp()
230 self.iters = 100
231 self.force_page_faults = True
232 self.is_huge = False
233
234 def create_players(self, resource, **resource_arg):
235 """
236 Init odp tests resources.
237 :param resource: The RDMA resources to use. A class of type
238 BaseResources.
239 :param resource_arg: Dict of args that specify the resource specific
240 attributes.
241 """
242 sync_attrs = False if resource == OdpUD else True
243 super().create_players(resource, sync_attrs, **resource_arg)
244 self.traffic_args['force_page_faults'] = self.force_page_faults
245
246 def tearDown(self):
247 if self.server and self.server.user_addr:
248 length = HUGE_PAGE_SIZE if self.is_huge else self.server.msg_size
249 munmap(self.server.user_addr, length)
250 if self.client and self.client.user_addr:
251 length = HUGE_PAGE_SIZE if self.is_huge else self.client.msg_size
252 munmap(self.client.user_addr, length)
253 super(OdpTestCase, self).tearDown()
254
255 def test_odp_rc_traffic(self):
256 self.create_players(OdpRC, request_user_addr=self.force_page_faults)
257 u.traffic(**self.traffic_args)
258
259 def test_odp_rc_mixed_mr(self):
260 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
261 use_mixed_mr=True)
262 u.traffic(**self.traffic_args)
263
264 def test_odp_qp_ex_rc_atomic_write(self):
265 super().create_players(OdpQpExRC, request_user_addr=self.force_page_faults,
266 msg_size=8, odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_ATOMIC_WRITE)
267 self.client.msg_size = 8
268 self.server.msg_size = 8
269 u.rdma_traffic(**self.traffic_args,
270 new_send=True, send_op=ibv_wr_opcode.IBV_WR_ATOMIC_WRITE)
271
272 def test_odp_qp_ex_rc_flush(self):
273 super().create_players(OdpQpExRC, request_user_addr=self.force_page_faults,
274 odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_FLUSH)
275 wcs = u.flush_traffic(**self.traffic_args, new_send=True,
276 send_op=ibv_wr_opcode.IBV_WR_FLUSH)
277 if wcs[0].status != ibv_wc_status.IBV_WC_SUCCESS:
278 raise PyverbsError(f'Unexpected {u.wc_status_to_str(wcs[0].status)}')
279
280 self.client.level = ibv_selectivity_level.IBV_FLUSH_MR
281 wcs = u.flush_traffic(**self.traffic_args, new_send=True,
282 send_op=ibv_wr_opcode.IBV_WR_FLUSH)
283 if wcs[0].status != ibv_wc_status.IBV_WC_SUCCESS:
284 raise PyverbsError(f'Unexpected {u.wc_status_to_str(wcs[0].status)}')
285
286 def test_odp_rc_atomic_cmp_and_swp(self):
287 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
288 msg_size=8, odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_ATOMIC)
289 u.atomic_traffic(**self.traffic_args,
290 send_op=ibv_wr_opcode.IBV_WR_ATOMIC_CMP_AND_SWP)
291 u.atomic_traffic(**self.traffic_args, receiver_val=1, sender_val=1,
292 send_op=ibv_wr_opcode.IBV_WR_ATOMIC_CMP_AND_SWP)
293
294 def test_odp_rc_atomic_fetch_and_add(self):
295 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
296 msg_size=8, odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_ATOMIC)
297 u.atomic_traffic(**self.traffic_args,
298 send_op=ibv_wr_opcode.IBV_WR_ATOMIC_FETCH_AND_ADD)
299
300 def test_odp_rc_rdma_read(self):
301 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
302 odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_READ)
303 self.server.mr.write('s' * self.server.msg_size, self.server.msg_size)
304 u.rdma_traffic(**self.traffic_args, send_op=ibv_wr_opcode.IBV_WR_RDMA_READ)
305
306 def test_odp_rc_rdma_write(self):
307 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
308 odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_WRITE)
309 u.rdma_traffic(**self.traffic_args, send_op=ibv_wr_opcode.IBV_WR_RDMA_WRITE)
310
311 def test_odp_implicit_rc_traffic(self):
312 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
313 is_implicit=True)
314 u.traffic(**self.traffic_args)
315
316 def test_odp_ud_traffic(self):
317 self.create_players(OdpUD, request_user_addr=self.force_page_faults)
318 # Implement the traffic here because OdpUD uses two different MRs for
319 # send and recv.
320 ah_client = u.get_global_ah(self.client, self.gid_index, self.ib_port)
321 recv_sge = SGE(self.server.recv_mr.buf, self.server.msg_size +
322 u.GRH_SIZE, self.server.recv_mr.lkey)
323 server_recv_wr = RecvWR(sg=[recv_sge], num_sge=1)
324 send_sge = SGE(self.client.send_mr.buf + u.GRH_SIZE,
325 self.client.msg_size, self.client.send_mr.lkey)
326 client_send_wr = SendWR(num_sge=1, sg=[send_sge])
327 for i in range(self.iters):
328 madvise(self.client.send_mr.buf, self.client.msg_size)
329 self.server.qp.post_recv(server_recv_wr)
330 u.post_send(self.client, client_send_wr, ah=ah_client)
331 u.poll_cq(self.client.cq)
332 u.poll_cq(self.server.cq)
333
334 def test_odp_xrc_traffic(self):
335 self.create_players(OdpXRC, request_user_addr=self.force_page_faults)
336 u.xrc_traffic(self.client, self.server)
337
338 @u.requires_huge_pages()
339 def test_odp_rc_huge_traffic(self):
340 self.force_page_faults = False
341 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
342 is_huge=True)
343 u.traffic(**self.traffic_args)
344
345 @u.requires_huge_pages()
346 def test_odp_rc_huge_user_addr_traffic(self):
347 self.is_huge = True
348 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
349 is_huge=True)
350 u.traffic(**self.traffic_args)
351
352 def test_odp_sync_prefetch_rc_traffic(self):
353 for advice in [_IBV_ADVISE_MR_ADVICE_PREFETCH,
354 _IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE]:
355 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
356 use_mr_prefetch='sync', prefetch_advice=advice)
357 u.traffic(**self.traffic_args)
358
359 def test_odp_async_prefetch_rc_traffic(self):
360 for advice in [_IBV_ADVISE_MR_ADVICE_PREFETCH,
361 _IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE]:
362 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
363 use_mr_prefetch='async', prefetch_advice=advice)
364 u.traffic(**self.traffic_args)
365
366 def test_odp_implicit_sync_prefetch_rc_traffic(self):
367 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
368 use_mr_prefetch='sync', is_implicit=True)
369 u.traffic(**self.traffic_args)
370
371 def test_odp_implicit_async_prefetch_rc_traffic(self):
372 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
373 use_mr_prefetch='async', is_implicit=True)
374 u.traffic(**self.traffic_args)
375
376 def test_odp_prefetch_sync_no_page_fault_rc_traffic(self):
377 prefetch_advice = _IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT
378 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
379 use_mr_prefetch='sync', prefetch_advice=prefetch_advice)
380 u.traffic(**self.traffic_args)
381
382 def test_odp_prefetch_async_no_page_fault_rc_traffic(self):
383 prefetch_advice = _IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT
384 self.create_players(OdpRC, request_user_addr=self.force_page_faults,
385 use_mr_prefetch='async', prefetch_advice=prefetch_advice)
386 u.traffic(**self.traffic_args)
387
388 def test_mrex_odp_rc_traffic(self):
389 """
390 Test ODP traffic with MREx
391 """
392 self.create_players(MRExOdpRC, request_user_addr=self.force_page_faults)
393 u.traffic(**self.traffic_args)
394
395 @u.requires_huge_pages()
396 def test_mrex_odp_rc_huge_traffic(self):
397 self.force_page_faults = False
398 self.create_players(MRExOdpRC, request_user_addr=self.force_page_faults,
399 is_huge=True)
400 u.traffic(**self.traffic_args)
401
402 def test_mrex_odp_implicit_rc_traffic(self):
403 """
404 Test ODP implicit traffic with MREx
405 """
406 self.create_players(MRExOdpRC, request_user_addr=self.force_page_faults,
407 is_implicit=True)
408 u.traffic(**self.traffic_args)
409
410 def test_mrex_odp_qp_ex_rc_flush(self):
411 """
412 Test ODP QP extended flush with MREx
413 """
414 super().create_players(OdpQpExMRExRC, request_user_addr=self.force_page_faults,
415 odp_caps=ibv_odp_transport_cap_bits.IBV_ODP_SUPPORT_FLUSH)
416 wcs = u.flush_traffic(**self.traffic_args, new_send=True,
417 send_op=ibv_wr_opcode.IBV_WR_FLUSH)
418 if wcs[0].status != ibv_wc_status.IBV_WC_SUCCESS:
419 raise PyverbsError(f'Unexpected {u.wc_status_to_str(wcs[0].status)}')
420
421 self.client.level = ibv_selectivity_level.IBV_FLUSH_MR
422 wcs = u.flush_traffic(**self.traffic_args, new_send=True,
423 send_op=ibv_wr_opcode.IBV_WR_FLUSH)
424 if wcs[0].status != ibv_wc_status.IBV_WC_SUCCESS:
425 raise PyverbsError(f'Unexpected {u.wc_status_to_str(wcs[0].status)}')