def build_traffic_elements_sig_pipelining(self):
"""
Build two WRs for data and response on client side and one WR for
response on server side. Transaction consists of two operations:
RDMA write of data and send/recv of response. Data size is
512 bytes, response size is 16 bytes. For simplicity the same
memory is used for data and response. Data is transferred using
the player signature mkey. Response is transferred using the
plain MR.
"""
server_sge_resp = SGE(self.server.mr.buf, 16, self.server.mr.lkey)
self.server_resp_wr = RecvWR(sg=[server_sge_resp], num_sge=1)
client_sge_data = SGE(0, 512, self.client.mkey.lkey)
self.client_data_wr = SendWR(wr_id=1,
opcode=e.IBV_WR_RDMA_WRITE,
num_sge=1,
sg=[client_sge_data],
send_flags=0)
self.client_data_wr.set_wr_rdma(self.server.mkey.rkey, 0)
client_sge_resp = SGE(self.client.mr.buf, 16, self.client.mr.lkey)
client_send_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_FENCE
self.client_resp_wr = SendWR(wr_id=1,
opcode=e.IBV_WR_SEND,
num_sge=1,
sg=[client_sge_resp],
send_flags=client_send_flags)
def get_send_elements(self, tag=0, tm_opcode=e.IBV_TMH_EAGER, tm=True):
"""
Creates a single SGE and a single Send WR for client QP. The content
of the message is 'c' for client side. The function also generates TMH
and RVH to the msg
:return: Send wr and expected msg that is read from mr
"""
sge = SGE(self.client.mr.buf, self.client.msg_size, self.client.mr_lkey)
if tm_opcode == e.IBV_TMH_RNDV:
max_rndv_hdr_size = self.server.ctx.query_device_ex().tm_caps.max_rndv_hdr_size
sge.length = max_rndv_hdr_size if max_rndv_hdr_size <= self.server.mr.length else \
self.server.mr.length
write_rndvu_header(player=self.client, mr=self.client.mr, tag=tag, tm_opcode=tm_opcode)
c_recv_wr = RecvWR(wr_id=tag, sg=[sge], num_sge=1)
# Need to post_recv client because the server sends rdma-read request to client
u.post_recv(self.client, c_recv_wr)
else:
msg = self.client.msg_size * 'c'
self.client.mr.write(msg, self.client.msg_size)
if tm:
write_tm_header(mr=self.client.mr, tag=tag, tm_opcode=tm_opcode)
send_wr = SendWR(opcode=e.IBV_WR_SEND, num_sge=1, sg=[sge])
exp_msg = self.client.mr.read(self.client.msg_size, 0)
return send_wr, exp_msg
def build_traffic_elements(self, sge_size):
"""
Build the server and client send/recv work requests.
:param sge_size: The sge send size using the mkey.
"""
opcode = e.IBV_WR_SEND
server_sge = SGE(0, sge_size, self.server.mkey.lkey)
self.server_recv_wr = RecvWR(sg=[server_sge], num_sge=1)
client_sge = SGE(0, sge_size, self.client.mkey.lkey)
self.client_send_wr = SendWR(opcode=opcode, num_sge=1, sg=[client_sge])
def get_recv_wr(agr_obj):
"""
Creates a single SGE Recv WR for agr_obj's QP type.
:param agr_obj: Aggregation object which contains all resources necessary
:return: recv wr
"""
qp_type = agr_obj.qp.qp_type
mr = agr_obj.mr
if qp_type == e.IBV_QPT_UD:
recv_sge = SGE(mr.buf, agr_obj.msg_size + GRH_SIZE, mr.lkey)
else:
recv_sge = SGE(mr.buf, agr_obj.msg_size, mr.lkey)
return RecvWR(sg=[recv_sge], num_sge=1)
def test_odp_ud_traffic(self):
client, server = self.create_players(OdpUD)
# Implement the traffic here because OdpUD uses two different MRs for
# send and recv.
recv_sge = SGE(server.recv_mr.buf, server.msg_size + GRH_SIZE,
server.recv_mr.lkey)
server_recv_wr = RecvWR(sg=[recv_sge], num_sge=1)
send_sge = SGE(client.send_mr.buf + GRH_SIZE, client.msg_size,
client.send_mr.lkey)
client_send_wr = SendWR(num_sge=1, sg=[send_sge])
for i in range(self.iters):
server.qp.post_recv(server_recv_wr)
post_send(client, client_send_wr, self.gid_index, self.ib_port)
poll_cq(client.cq)
poll_cq(server.cq)
def reg_mr_sig_t10dif(self):
"""
Register the player's mkeys with T10DIF signature on the wire domain.
"""
for player in [self.server, self.client]:
player.qp.wr_start()
player.qp.wr_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_INLINE
sge = SGE(player.mr.buf, 512, player.mr.lkey)
player.qp.wr_mkey_configure(player.mkey, 3, Mlx5MkeyConfAttr())
player.qp.wr_set_mkey_access_flags(e.IBV_ACCESS_LOCAL_WRITE)
player.qp.wr_set_mkey_layout_list([sge])
t10dif_flags = (dve.MLX5DV_SIG_T10DIF_FLAG_REF_REMAP
| dve.MLX5DV_SIG_T10DIF_FLAG_APP_ESCAPE
| dve.MLX5DV_SIG_T10DIF_FLAG_APP_REF_ESCAPE)
sig_t10dif = Mlx5SigT10Dif(bg_type=dve.MLX5DV_SIG_T10DIF_CRC,
bg=0xFFFF,
app_tag=0xABCD,
ref_tag=0x01234567,
flags=t10dif_flags)
sig_type = dve.MLX5DV_SIG_TYPE_T10DIF
block_size = dve.MLX5DV_BLOCK_SIZE_512
sig_block_domain = Mlx5SigBlockDomain(sig_type=sig_type,
dif=sig_t10dif,
block_size=block_size)
check_mask = (dve.MLX5DV_SIG_MASK_T10DIF_GUARD
| dve.MLX5DV_SIG_MASK_T10DIF_APPTAG
| dve.MLX5DV_SIG_MASK_T10DIF_REFTAG)
sig_attr = Mlx5SigBlockAttr(wire=sig_block_domain,
check_mask=check_mask)
player.qp.wr_set_mkey_sig_block(sig_attr)
player.qp.wr_complete()
u.poll_cq(player.cq)
def reg_client_mkey(self, signature=False):
"""
Configure an mkey with crypto attributes.
:param signature: True if signature configuration requested.
"""
num_of_configuration = 4 if signature else 3
for mkey in [self.client.wire_enc_mkey, self.client.mem_enc_mkey]:
self.client.qp.wr_start()
self.client.qp.wr_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_INLINE
offset = 0 if mkey == self.client.wire_enc_mkey else self.client.msg_size/2
sge = SGE(self.client.mr.buf + offset, self.client.msg_size/2, self.client.mr.lkey)
self.client.qp.wr_mkey_configure(mkey, num_of_configuration, Mlx5MkeyConfAttr())
self.client.qp.wr_set_mkey_access_flags(e.IBV_ACCESS_LOCAL_WRITE)
self.client.qp.wr_set_mkey_layout_list([sge])
if signature:
self.configure_mkey_signature()
initial_tweak = struct.pack('!2Q', int(0), int(0))
encrypt_on_tx = mkey == self.client.wire_enc_mkey
sign_crypto_order = dve.MLX5DV_SIGNATURE_CRYPTO_ORDER_SIGNATURE_BEFORE_CRYPTO_ON_TX
crypto_attr = Mlx5CryptoAttr(crypto_standard=dve.MLX5DV_CRYPTO_STANDARD_AES_XTS,
encrypt_on_tx=encrypt_on_tx,
signature_crypto_order=sign_crypto_order,
data_unit_size=dve.MLX5DV_BLOCK_SIZE_512,
dek=self.dek, initial_tweak=initial_tweak)
self.client.qp.wr_set_mkey_crypto(crypto_attr)
self.client.qp.wr_complete()
u.poll_cq(self.client.cq)
def get_send_wr(agr_obj, is_server):
"""
Creates a single SGE Send WR for agr_obj's QP type. The content of the
message is either 's' for server side or 'c' for client side.
:param agr_obj: Aggregation object which contains all resources necessary
:param is_server: Indicates whether this is server or client side
:return: send wr
"""
qp_type = agr_obj.qp.qp_type
mr = agr_obj.mr
if qp_type == e.IBV_QPT_UD:
send_sge = SGE(mr.buf + GRH_SIZE, agr_obj.msg_size, mr.lkey)
else:
send_sge = SGE(mr.buf, agr_obj.msg_size, mr.lkey)
msg = agr_obj.msg_size * ('s' if is_server else 'c')
mr.write(msg, agr_obj.msg_size)
return SendWR(num_sge=1, sg=[send_sge])
def reg_mr_list(self, configure_mkey=False):
"""
Register a list of SGEs using the player's mkeys.
:param configure_mkey: If True, use the mkey configuration API.
"""
for player in [self.server, self.client]:
player.qp.wr_start()
player.qp.wr_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_INLINE
sge_1 = SGE(player.mr.buf, 8, player.mr.lkey)
sge_2 = SGE(player.mr.buf + 64, 8, player.mr.lkey)
if configure_mkey:
player.qp.wr_mkey_configure(player.mkey, 2, Mlx5MkeyConfAttr())
player.qp.wr_set_mkey_access_flags(e.IBV_ACCESS_LOCAL_WRITE)
player.qp.wr_set_mkey_layout_list([sge_1, sge_2])
else:
player.qp.wr_mr_list(player.mkey,
e.IBV_ACCESS_LOCAL_WRITE,
sge_list=[sge_1, sge_2])
player.qp.wr_complete()
u.poll_cq(player.cq)
def post_recv_tm(self, tag, wrid):
"""
Create opswr according to user chooce of wr_id and a tag
and post recv it with the srq and the special func
post_srq_ops that posted opswr wqe.
:return: The opswr'
"""
recv_sge = SGE(self.server.mr.buf, self.server.msg_size, self.server.mr.lkey)
wr = OpsWr(wr_id=wrid, unexpected_cnt=self.server.unexp_cnt, recv_wr_id=wrid, num_sge=1,
tag=tag, mask=TAG_MASK, sg_list=[recv_sge])
self.server.srq.post_srq_ops(wr)
return wr
def reg_mr_sig_err(self):
"""
Register the player's mkeys with an SGE and CRC32 signature on
the memory domain. Data transport operation with these MKEYs will cause
a signature error because the test does not fill out the signature in
the memory buffer.
"""
sig_crc = Mlx5SigCrc(crc_type=dve.MLX5DV_SIG_CRC_TYPE_CRC32,
seed=0xFFFFFFFF)
block_size = dve.MLX5DV_BLOCK_SIZE_512
sig_block_domain = Mlx5SigBlockDomain(sig_type=dve.MLX5DV_SIG_TYPE_CRC,
crc=sig_crc,
block_size=block_size)
sig_attr = Mlx5SigBlockAttr(mem=sig_block_domain,
check_mask=dve.MLX5DV_SIG_MASK_CRC32)
# Configure the mkey on the server side
self.server.qp.wr_start()
self.server.qp.wr_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_INLINE
sge = SGE(self.server.mr.buf, 512, self.server.mr.lkey)
self.server.qp.wr_mkey_configure(self.server.mkey, 2,
Mlx5MkeyConfAttr())
self.server.qp.wr_set_mkey_access_flags(e.IBV_ACCESS_LOCAL_WRITE)
self.server.qp.wr_set_mkey_layout_list([sge])
self.server.qp.wr_complete()
u.poll_cq(self.server.cq)
# Configure the mkey on the client side
self.client.qp.wr_start()
self.client.qp.wr_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_INLINE
sge = SGE(self.client.mr.buf, 512 + 4, self.client.mr.lkey)
self.client.qp.wr_mkey_configure(self.client.mkey, 3,
Mlx5MkeyConfAttr())
self.client.qp.wr_set_mkey_access_flags(e.IBV_ACCESS_LOCAL_WRITE)
self.client.qp.wr_set_mkey_layout_list([sge])
self.client.qp.wr_set_mkey_sig_block(sig_attr)
self.client.qp.wr_complete()
u.poll_cq(self.client.cq)
def get_recv_wr(agr_obj):
"""
Creates a single SGE Recv WR for agr_obj's QP type.
:param agr_obj: Aggregation object which contains all resources necessary
:return: recv wr
"""
qp_type = agr_obj.rqp_lst[0].qp_type if isinstance(agr_obj, XRCResources) \
else agr_obj.qp.qp_type
mr = agr_obj.mr
length = agr_obj.msg_size + GRH_SIZE if qp_type == e.IBV_QPT_UD \
else agr_obj.msg_size
recv_sge = SGE(mr.buf, length, mr.lkey)
return RecvWR(sg=[recv_sge], num_sge=1)
def reg_mr_sig_pipelining_server(self):
"""
Register mkey without signature.
"""
self.server.qp.wr_start()
self.server.qp.wr_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_INLINE
sge = SGE(self.server.mr.buf, 512, self.server.mr.lkey)
self.server.qp.wr_mkey_configure(self.server.mkey, 2,
Mlx5MkeyConfAttr())
self.server.qp.wr_set_mkey_access_flags(e.IBV_ACCESS_LOCAL_WRITE
| e.IBV_ACCESS_REMOTE_WRITE)
self.server.qp.wr_set_mkey_layout_list([sge])
self.server.qp.wr_complete()
u.poll_cq(self.server.cq)
def get_atomic_send_elements(agr_obj, opcode, cmp_add=0, swap=0):
"""
Creates a single SGE and a single Send WR for atomic operations.
:param agr_obj: Aggregation object which contains all resources necessary
:param opcode: The send opcode
:param cmp_add: The compare or add value (depends on the opcode).
:param swap: The swap value.
:return: Send WR and its SGE
"""
sge = SGE(agr_obj.mr.buf, 8, agr_obj.mr_lkey)
send_wr = SendWR(opcode=opcode, num_sge=1, sg=[sge])
send_wr.set_wr_atomic(rkey=int(agr_obj.rkey), addr=int(agr_obj.raddr),
compare_add=int8b_from_int(cmp_add),
swap=int8b_from_int(swap))
return send_wr, sge
def prepare_send_elements(self):
mr = self.client.mr
sge_count = 2
unit_size = mr.length / 2
data_segs = [
WqeDataSeg(unit_size, mr.lkey, mr.buf + i * unit_size)
for i in range(sge_count)
]
ctrl_seg = WqeCtrlSeg()
ctrl_seg.fm_ce_se = dve.MLX5_WQE_CTRL_CQ_UPDATE
segment_num = 1 + len(data_segs)
ctrl_seg.opmod_idx_opcode = dve.MLX5_OPCODE_SEND
ctrl_seg.qpn_ds = segment_num | int(self.client.qp.qp_num) << 8
self.raw_send_wqe = Wqe([ctrl_seg] + data_segs)
self.regular_send_sge = SGE(mr.buf, mr.length, mr.lkey)
def get_send_elements(agr_obj, is_server):
"""
Creates a single SGE and a single Send WR for agr_obj's QP type. The content
of the message is either 's' for server side or 'c' for client side.
:param agr_obj: Aggregation object which contains all resources necessary
:param is_server: Indicates whether this is server or client side
:return: send wr and its SGE
"""
mr = agr_obj.mr
qp_type = agr_obj.sqp_lst[0].qp_type if isinstance(agr_obj, XRCResources) \
else agr_obj.qp.qp_type
offset = GRH_SIZE if qp_type == e.IBV_QPT_UD else 0
msg = (agr_obj.msg_size + offset) * ('s' if is_server else 'c')
mr.write(msg, agr_obj.msg_size + offset)
sge = SGE(mr.buf + offset, agr_obj.msg_size, mr.lkey)
return SendWR(num_sge=1, sg=[sge]), sge
def get_send_elements_raw_qp(agr_obj, l3=PacketConsts.IP_V4,
l4=PacketConsts.UDP_PROTO):
"""
Creates a single SGE and a single Send WR for agr_obj's RAW QP type. The
content of the message is Eth | Ipv4 | UDP packet.
:param agr_obj: Aggregation object which contains all resources necessary
:param l3: Packet layer 3 type: 4 for IPv4 or 6 for IPv6
:param l4: Packet layer 4 type: 'tcp' or 'udp'
:return: send wr, its SGE, and message
"""
mr = agr_obj.mr
msg = gen_packet(agr_obj.msg_size, l3, l4)
mr.write(msg, agr_obj.msg_size)
sge = SGE(mr.buf, agr_obj.msg_size, mr.lkey)
send_wr = SendWR(opcode=e.IBV_WR_SEND, num_sge=1, sg=[sge])
return send_wr, sge, msg
def get_send_elements(agr_obj, is_server, opcode=e.IBV_WR_SEND):
"""
Creates a single SGE and a single Send WR for agr_obj's QP type. The content
of the message is either 's' for server side or 'c' for client side.
:param agr_obj: Aggregation object which contains all resources necessary
:param is_server: Indicates whether this is server or client side
:return: send wr and its SGE
"""
mr = agr_obj.mr
qp_type = agr_obj.sqp_lst[0].qp_type if isinstance(agr_obj, XRCResources) \
else agr_obj.qp.qp_type
offset = GRH_SIZE if qp_type == e.IBV_QPT_UD else 0
msg = (agr_obj.msg_size + offset) * ('s' if is_server else 'c')
mr.write(msg, agr_obj.msg_size + offset)
sge = SGE(mr.buf + offset, agr_obj.msg_size, mr.lkey)
send_wr = SendWR(opcode=opcode, num_sge=1, sg=[sge])
if opcode in [e.IBV_WR_RDMA_WRITE, e.IBV_WR_RDMA_READ]:
send_wr.set_wr_rdma(int(agr_obj.rkey), int(agr_obj.remote_addr))
return send_wr, sge
def reg_mr_sig_pipelining_client(self, check_mask=0):
"""
Register mkey with CRC32 signature in memory domain and no
signature in wire domain.
:param check_mask: The mask for the signature checking.
"""
self.client.qp.wr_start()
self.client.qp.wr_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_INLINE
# Add 4 bytes for CRC32 signature
sge = SGE(self.client.mr.buf, 512 + 4, self.client.mr.lkey)
self.client.qp.wr_mkey_configure(self.client.mkey, 3,
Mlx5MkeyConfAttr())
self.client.qp.wr_set_mkey_access_flags(e.IBV_ACCESS_LOCAL_WRITE)
self.client.qp.wr_set_mkey_layout_list([sge])
sig = Mlx5SigCrc(crc_type=dve.MLX5DV_SIG_CRC_TYPE_CRC32)
sig_domain = Mlx5SigBlockDomain(sig_type=dve.MLX5DV_SIG_TYPE_CRC,
crc=sig,
block_size=dve.MLX5DV_BLOCK_SIZE_512)
sig_attr = Mlx5SigBlockAttr(mem=sig_domain, check_mask=check_mask)
self.client.qp.wr_set_mkey_sig_block(sig_attr)
self.client.qp.wr_complete()
u.poll_cq(self.client.cq)
def reg_mr_sig_crc(self):
"""
Register the player's mkeys with CRC32 signature on the wire domain.
"""
for player in [self.server, self.client]:
player.qp.wr_start()
player.qp.wr_flags = e.IBV_SEND_SIGNALED | e.IBV_SEND_INLINE
sge = SGE(player.mr.buf, 512, player.mr.lkey)
player.qp.wr_mkey_configure(player.mkey, 3, Mlx5MkeyConfAttr())
player.qp.wr_set_mkey_access_flags(e.IBV_ACCESS_LOCAL_WRITE)
player.qp.wr_set_mkey_layout_list([sge])
sig_crc = Mlx5SigCrc(crc_type=dve.MLX5DV_SIG_CRC_TYPE_CRC32,
seed=0xFFFFFFFF)
sig_block_domain = Mlx5SigBlockDomain(
sig_type=dve.MLX5DV_SIG_TYPE_CRC,
crc=sig_crc,
block_size=dve.MLX5DV_BLOCK_SIZE_512)
sig_attr = Mlx5SigBlockAttr(wire=sig_block_domain,
check_mask=dve.MLX5DV_SIG_MASK_CRC32)
player.qp.wr_set_mkey_sig_block(sig_attr)
player.qp.wr_complete()
u.poll_cq(player.cq)
def get_send_wr(self, player, wire_encryption):
mkey = player.wire_enc_mkey if wire_encryption else player.mem_enc_mkey
sge = SGE(0, player.msg_size/2, mkey.lkey)
return SendWR(opcode=e.IBV_WR_SEND, num_sge=1, sg=[sge])
def get_recv_wr(self, player, wire_encryption):
offset = 0 if wire_encryption else player.msg_size/2
sge = SGE(player.mr.buf + offset, player.msg_size/2, player.mr.lkey)
return RecvWR(sg=[sge], num_sge=1)