def test_imported_rc_ex_rdma_write(self):
setup_params = {
'dev_name': self.dev_name,
'ib_port': self.ib_port,
'gid_index': self.gid_index
}
self.server_res = QpExRCRDMAWrite(**setup_params)
cmd_fd_dup = os.dup(self.server_res.ctx.cmd_fd)
import_cls = get_import_res_class(QpExRCRDMAWrite)
server_import = import_cls(
cmd_fd_dup,
self.server_res.pd.handle,
self.server_res.mr.handle,
# The imported MR's address is NULL, so using the address of the
# "main" MR object to be able to validate the message
self.server_res.mr.buf,
**setup_params)
self.imported_res.append(server_import)
client = QpExRCRDMAWrite(**setup_params)
client.pre_run(server_import.psn, server_import.qpn)
server_import.pre_run(client.psn, client.qpn)
client.rkey = server_import.mr.rkey
server_import.rkey = client.mr.rkey
client.raddr = server_import.mr.buf
server_import.raddr = client.mr.buf
u.rdma_traffic(client,
server_import,
self.iters,
self.gid_index,
self.ib_port,
send_op=e.IBV_QP_EX_WITH_RDMA_WRITE)
def test_dc_rdma_write(self):
self.create_players(Mlx5DcResources,
qp_count=2,
send_ops_flags=e.IBV_QP_EX_WITH_RDMA_WRITE)
u.rdma_traffic(**self.traffic_args,
new_send=True,
send_op=e.IBV_QP_EX_WITH_RDMA_WRITE)
def test_mw_type2_invalidate_dealloc(self):
self.test_mw_type2()
# Dealloc the MW by closing the pyverbs objects.
self.server.mw.close()
self.client.mw.close()
with self.assertRaisesRegex(PyverbsRDMAError, 'Remote access error'):
u.rdma_traffic(self.client, self.server, self.iters, self.gid_index,
self.ib_port, send_op=e.IBV_WR_RDMA_WRITE)
def test_qp_ex_rc_rdma_write(self):
client, server = self.create_players('rc_write')
client.rkey = server.mr.rkey
server.rkey = client.mr.rkey
client.raddr = server.mr.buf
server.raddr = client.mr.buf
u.rdma_traffic(client, server, self.iters, self.gid_index, self.ib_port,
is_cq_ex=False, send_op=e.IBV_QP_EX_WITH_RDMA_WRITE)
def test_mw_type2(self):
self.create_players(MWRC, mw_type=e.IBV_MW_TYPE_2)
self.bind_mw_type_2()
u.rdma_traffic(self.client,
self.server,
self.iters,
self.gid_index,
self.ib_port,
send_op=e.IBV_WR_RDMA_WRITE)
def test_qp_ex_rc_rdma_read(self):
client, server = self.create_players('rc_read')
client.rkey = server.mr.rkey
server.rkey = client.mr.rkey
client.raddr = server.mr.buf
server.raddr = client.mr.buf
server.mr.write('s' * server.msg_size, server.msg_size)
u.rdma_traffic(client, server, self.iters, self.gid_index, self.ib_port,
is_cq_ex=False, send_op=e.IBV_QP_EX_WITH_RDMA_READ)
def test_mw_type2_invalidate_remote(self):
self.test_mw_type2()
self.invalidate_mw_type2_remote()
with self.assertRaisesRegex(PyverbsRDMAError, 'Remote access error'):
u.rdma_traffic(self.client,
self.server,
self.iters,
self.gid_index,
self.ib_port,
send_op=e.IBV_WR_RDMA_WRITE)
def test_qp_ex_rc_atomic_fetch_add(self):
client, server = self.create_players('rc_fetch_add')
client.msg_size = 8 # Atomic work on 64b operators
server.msg_size = 8
client.rkey = server.mr.rkey
server.rkey = client.mr.rkey
client.raddr = server.mr.buf
server.raddr = client.mr.buf
server.mr.write('s' * 8, 8)
u.rdma_traffic(client, server, self.iters, self.gid_index, self.ib_port,
is_cq_ex=False, send_op=e.IBV_QP_EX_WITH_ATOMIC_FETCH_AND_ADD)
def test_dmabuf_rdma_traffic(self):
"""
Test rdma write using dma-buf MR
"""
client, server = self.create_players(DmaBufRC, gpu=self.gpu,
gtt=self.gtt)
server.rkey = client.mr.rkey
server.remote_addr = client.mr.offset
client.rkey = server.mr.rkey
client.remote_addr = server.mr.offset
u.rdma_traffic(client, server, self.iters, self.gid_index, self.ib_port,
send_op=e.IBV_WR_RDMA_WRITE)
def test_mr_rereg_access_bad_flow(self):
"""
Test that cover rereg MR's access with this flow:
Run remote traffic on MR with compatible access, then rereg the MR
without remote access and verify that traffic fails with the relevant
error.
"""
remote_access = e.IBV_ACCESS_LOCAL_WRITE | e.IBV_ACCESS_REMOTE_WRITE
self.create_players(MRRes, mr_access=remote_access)
u.rdma_traffic(**self.traffic_args, send_op=e.IBV_WR_RDMA_WRITE)
access = e.IBV_ACCESS_LOCAL_WRITE
self.server.rereg_mr(flags=e.IBV_REREG_MR_CHANGE_ACCESS, access=access)
with self.assertRaisesRegex(PyverbsRDMAError, 'Remote access error'):
u.rdma_traffic(**self.traffic_args, send_op=e.IBV_WR_RDMA_WRITE)
def test_qp_ex_srd_rdma_read(self):
send_op = e.IBV_QP_EX_WITH_RDMA_READ
self.create_players(send_op)
self.client.rkey = self.server.mr.rkey
self.server.rkey = self.client.mr.rkey
self.client.raddr = self.server.mr.buf
self.server.raddr = self.client.mr.buf
self.server.mr.write('s' * self.server.msg_size, self.server.msg_size)
u.rdma_traffic(self.client,
self.server,
self.iters,
self.gid_index,
self.ib_port,
new_send=True,
send_op=send_op)
def test_dc_rdma_write_stream(self):
"""
Check good flow of DCS.
Calculate stream_id for DCS test by setting same stream id
twice for WR and after increase it. Setting goes by loop
and after stream_id is more than number of concurrent
streams + 1 then stream_id returns to 1.
:raises SkipTest: In case DCI is not supported with HW
"""
self.create_players(Mlx5DcStreamsRes,
qp_count=2,
send_ops_flags=e.IBV_QP_EX_WITH_RDMA_WRITE)
u.rdma_traffic(**self.traffic_args,
new_send=True,
send_op=e.IBV_QP_EX_WITH_RDMA_WRITE)
def test_qp_ex_rc_atomic_cmp_swp(self):
client, server = self.create_players('rc_cmp_swp')
client.msg_size = 8 # Atomic work on 64b operators
server.msg_size = 8
client.rkey = server.mr.rkey
server.rkey = client.mr.rkey
client.raddr = server.mr.buf
server.raddr = client.mr.buf
server.mr.write('s' * 8, 8)
u.rdma_traffic(client,
server,
self.iters,
self.gid_index,
self.ib_port,
new_send=True,
send_op=e.IBV_QP_EX_WITH_ATOMIC_CMP_AND_SWP)
def test_dm_remote_traffic(self):
self.create_players(DeviceMemoryRes, remote_access=True)
u.rdma_traffic(**self.traffic_args, send_op=e.IBV_WR_RDMA_WRITE)
def test_mr_rereg_access(self):
self.create_players(MRRes)
access = e.IBV_ACCESS_LOCAL_WRITE | e.IBV_ACCESS_REMOTE_WRITE
self.server.rereg_mr(flags=e.IBV_REREG_MR_CHANGE_ACCESS, access=access)
self.client.rereg_mr(flags=e.IBV_REREG_MR_CHANGE_ACCESS, access=access)
u.rdma_traffic(**self.traffic_args, send_op=e.IBV_WR_RDMA_WRITE)
