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)