| 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)}') |