diff --git a/prov/efa/src/efa_domain.c b/prov/efa/src/efa_domain.c index f1a81c89780..98fcdb24b5e 100644 --- a/prov/efa/src/efa_domain.c +++ b/prov/efa/src/efa_domain.c @@ -160,6 +160,7 @@ static int efa_domain_init_rdm(struct efa_domain *efa_domain, struct fi_info *in efa_domain->rdm_cq_size = MAX(info->rx_attr->size + info->tx_attr->size, efa_env.cq_size); efa_domain->num_read_msg_in_flight = 0; + efa_domain->num_runt_bytes_in_flight = 0; return 0; } diff --git a/prov/efa/src/efa_domain.h b/prov/efa/src/efa_domain.h index 1d74a9aa2ed..17240d7a8b9 100644 --- a/prov/efa/src/efa_domain.h +++ b/prov/efa/src/efa_domain.h @@ -30,7 +30,15 @@ struct efa_domain { size_t rdm_cq_size; struct dlist_entry list_entry; /* linked to g_efa_domain_list */ struct ofi_genlock srx_lock; /* shared among peer providers */ + /** + * @brief number of messages that are using read based protocol + */ uint64_t num_read_msg_in_flight; + /** + * @brief number of bytes that has been sent as part of runting protocols + * @details this value is capped by efa_env.efa_runt_size + */ + int64_t num_runt_bytes_in_flight; }; extern struct dlist_entry g_efa_domain_list; diff --git a/prov/efa/src/rdm/efa_rdm_ep.h b/prov/efa/src/rdm/efa_rdm_ep.h index 4469a27d29d..0f1d146d657 100644 --- a/prov/efa/src/rdm/efa_rdm_ep.h +++ b/prov/efa/src/rdm/efa_rdm_ep.h @@ -268,6 +268,10 @@ ssize_t efa_rdm_ep_post_queued_pkts(struct efa_rdm_ep *ep, size_t efa_rdm_ep_get_memory_alignment(struct efa_rdm_ep *ep, enum fi_hmem_iface iface); +size_t efa_rdm_ep_get_runt_size(struct efa_rdm_ep *ep, struct efa_rdm_ope *ope); + +int efa_rdm_ep_select_readbase_rtm(struct efa_rdm_ep *ep, struct efa_rdm_ope *ope); + static inline struct efa_domain *efa_rdm_ep_domain(struct efa_rdm_ep *ep) { diff --git a/prov/efa/src/rdm/efa_rdm_ep_utils.c b/prov/efa/src/rdm/efa_rdm_ep_utils.c index 2968a096318..f863ca74fbe 100644 --- a/prov/efa/src/rdm/efa_rdm_ep_utils.c +++ b/prov/efa/src/rdm/efa_rdm_ep_utils.c @@ -682,3 +682,59 @@ size_t efa_rdm_ep_get_memory_alignment(struct efa_rdm_ep *ep, enum fi_hmem_iface return memory_alignment; } +/** + * @brief Get the runt size for a given ep and ope + * + * @param ep efa rdm ep + * @param ope efa rdm ope + * @return size_t the number of bytes that can be runt + */ +size_t efa_rdm_ep_get_runt_size(struct efa_rdm_ep *ep, struct efa_rdm_ope *ope) +{ + struct efa_domain *domain = efa_rdm_ep_domain(ep); + struct efa_hmem_info *hmem_info; + size_t runt_size; + size_t memory_alignment; + int iface; + + hmem_info = domain->hmem_info; + iface = ope->desc[0] ? ((struct efa_mr*) ope->desc[0])->peer.iface : FI_HMEM_SYSTEM; + + if (domain->hmem_info[iface].runt_size < domain->num_runt_bytes_in_flight) + return 0; + + runt_size = MIN(hmem_info[iface].runt_size - domain->num_runt_bytes_in_flight, ope->total_len); + memory_alignment = efa_rdm_ep_get_memory_alignment(ep, iface); + /* + * runt size must be aligned because: + * 1. For LL128 protocol, the size to be copied on the receiver side must be 128-multiple, + * 128 is the alignment in this case. + * 2. For non-LL128 protocol, using aligned runt size has optimal performance for data copy. + * Note the returned value can be 0. In that case we will not use runting read protocol. + */ + return (runt_size & ~(memory_alignment - 1)); +} + +/** + * @brief Determine which Read based protocol to use + * + * @param[in] ep efa rdm ep + * @param[in] efa_rdm_ope efa rdm ope + * @return The read-based protocol to use based on inputs. + */ +int efa_rdm_ep_select_readbase_rtm(struct efa_rdm_ep *ep, struct efa_rdm_ope *ope) +{ + int op = ope->op; + + assert(op == ofi_op_tagged || op == ofi_op_msg); + + if (efa_rdm_ep_domain(ep)->num_read_msg_in_flight == 0 && + efa_rdm_ep_get_runt_size(ep, ope) > 0 && + !(ope->fi_flags & FI_DELIVERY_COMPLETE)) { + return (op == ofi_op_tagged) ? EFA_RDM_RUNTREAD_TAGRTM_PKT + : EFA_RDM_RUNTREAD_MSGRTM_PKT; + } else { + return (op == ofi_op_tagged) ? EFA_RDM_LONGREAD_TAGRTM_PKT + : EFA_RDM_LONGREAD_MSGRTM_PKT; + } +} diff --git a/prov/efa/src/rdm/efa_rdm_msg.c b/prov/efa/src/rdm/efa_rdm_msg.c index 7ff4a116928..b62c4fe1a02 100644 --- a/prov/efa/src/rdm/efa_rdm_msg.c +++ b/prov/efa/src/rdm/efa_rdm_msg.c @@ -86,7 +86,7 @@ int efa_rdm_msg_select_rtm(struct efa_rdm_ep *efa_rdm_ep, struct efa_rdm_ope *tx eager_rtm_max_data_size = efa_rdm_txe_max_req_data_capacity(efa_rdm_ep, txe, eager_rtm); - readbase_rtm = efa_rdm_peer_select_readbase_rtm(txe->peer, efa_rdm_ep, txe); + readbase_rtm = efa_rdm_ep_select_readbase_rtm(efa_rdm_ep, txe); if (txe->total_len >= hmem_info[iface].min_read_msg_size && efa_rdm_interop_rdma_read(efa_rdm_ep, txe->peer) && diff --git a/prov/efa/src/rdm/efa_rdm_ope.c b/prov/efa/src/rdm/efa_rdm_ope.c index c326a9b806c..e2b6013d910 100644 --- a/prov/efa/src/rdm/efa_rdm_ope.c +++ b/prov/efa/src/rdm/efa_rdm_ope.c @@ -324,17 +324,12 @@ int efa_rdm_txe_prepare_to_be_read(struct efa_rdm_ope *txe, struct fi_rma_iov *r static inline void efa_rdm_txe_set_runt_size(struct efa_rdm_ep *ep, struct efa_rdm_ope *txe) { - struct efa_rdm_peer *peer; - assert(txe->type == EFA_RDM_TXE); if (txe->bytes_runt > 0) return; - peer = efa_rdm_ep_get_peer(ep, txe->addr); - - assert(peer); - txe->bytes_runt = efa_rdm_peer_get_runt_size(peer, ep, txe); + txe->bytes_runt = efa_rdm_ep_get_runt_size(ep, txe); assert(txe->bytes_runt); } diff --git a/prov/efa/src/rdm/efa_rdm_peer.c b/prov/efa/src/rdm/efa_rdm_peer.c index 4a4d526ce4e..2839af8fee0 100644 --- a/prov/efa/src/rdm/efa_rdm_peer.c +++ b/prov/efa/src/rdm/efa_rdm_peer.c @@ -24,7 +24,6 @@ void efa_rdm_peer_construct(struct efa_rdm_peer *peer, struct efa_rdm_ep *ep, st peer->efa_fiaddr = conn->fi_addr; peer->is_self = efa_is_same_addr(&ep->base_ep.src_addr, conn->ep_addr); peer->host_id = peer->is_self ? ep->host_id : 0; /* Peer host id is exchanged via handshake */ - peer->num_runt_bytes_in_flight = 0; ofi_recvwin_buf_alloc(&peer->robuf, efa_env.recvwin_size); dlist_init(&peer->outstanding_tx_pkts); dlist_init(&peer->txe_list); @@ -223,62 +222,3 @@ void efa_rdm_peer_proc_pending_items_in_robuf(struct efa_rdm_peer *peer, struct return; } -/** - * @brief Get the runt size for a given peer and ope - * - * @param peer rdm peer - * @param ep efa rdm ep - * @param ope efa rdm ope - * @return size_t the number of bytes that can be runt - */ -size_t efa_rdm_peer_get_runt_size(struct efa_rdm_peer *peer, - struct efa_rdm_ep *ep, struct efa_rdm_ope *ope) -{ - struct efa_hmem_info *hmem_info; - size_t runt_size; - size_t memory_alignment; - int iface; - - hmem_info = efa_rdm_ep_domain(ep)->hmem_info; - iface = ope->desc[0] ? ((struct efa_mr*) ope->desc[0])->peer.iface : FI_HMEM_SYSTEM; - - if (hmem_info[iface].runt_size < peer->num_runt_bytes_in_flight) - return 0; - - runt_size = MIN(hmem_info[iface].runt_size - peer->num_runt_bytes_in_flight, ope->total_len); - memory_alignment = efa_rdm_ep_get_memory_alignment(ep, iface); - /* - * runt size must be aligned because: - * 1. For LL128 protocol, the size to be copied on the receiver side must be 128-multiple, - * 128 is the alignment in this case. - * 2. For non-LL128 protocol, using aligned runt size has optimal performance for data copy. - * Note the returned value can be 0. In that case we will not use runting read protocol. - */ - return (runt_size & ~(memory_alignment - 1)); -} - -/** - * @brief Determine which Read based protocol to use for a given peer - * - * @param[in] peer rdm peer - * @param[in] ep efa rdm ep - * @param[in] efa_rdm_ope efa rdm ope - * @return The read-based protocol to use based on inputs. - */ -int efa_rdm_peer_select_readbase_rtm(struct efa_rdm_peer *peer, - struct efa_rdm_ep *ep, struct efa_rdm_ope *ope) -{ - int op = ope->op; - - assert(op == ofi_op_tagged || op == ofi_op_msg); - - if (efa_rdm_ep_domain(ep)->num_read_msg_in_flight == 0 && - efa_rdm_peer_get_runt_size(peer, ep, ope) > 0 && - !(ope->fi_flags & FI_DELIVERY_COMPLETE)) { - return (op == ofi_op_tagged) ? EFA_RDM_RUNTREAD_TAGRTM_PKT - : EFA_RDM_RUNTREAD_MSGRTM_PKT; - } else { - return (op == ofi_op_tagged) ? EFA_RDM_LONGREAD_TAGRTM_PKT - : EFA_RDM_LONGREAD_MSGRTM_PKT; - } -} diff --git a/prov/efa/src/rdm/efa_rdm_peer.h b/prov/efa/src/rdm/efa_rdm_peer.h index 26d07298a08..3487929934d 100644 --- a/prov/efa/src/rdm/efa_rdm_peer.h +++ b/prov/efa/src/rdm/efa_rdm_peer.h @@ -52,12 +52,6 @@ struct efa_rdm_peer { struct dlist_entry rx_unexp_tagged_list; /**< a list of unexpected tagged rxe for this peer */ struct dlist_entry txe_list; /**< a list of txe related to this peer */ struct dlist_entry rxe_list; /**< a list of rxe relased to this peer */ - - /** - * @brief number of bytes that has been sent as part of runting protocols - * @details this value is capped by efa_env.efa_runt_size - */ - int64_t num_runt_bytes_in_flight; }; /** @@ -248,8 +242,4 @@ int efa_rdm_peer_reorder_msg(struct efa_rdm_peer *peer, struct efa_rdm_ep *ep, s void efa_rdm_peer_proc_pending_items_in_robuf(struct efa_rdm_peer *peer, struct efa_rdm_ep *ep); -size_t efa_rdm_peer_get_runt_size(struct efa_rdm_peer *peer, struct efa_rdm_ep *ep, struct efa_rdm_ope *ope); - -int efa_rdm_peer_select_readbase_rtm(struct efa_rdm_peer *peer, struct efa_rdm_ep *ep, struct efa_rdm_ope *ope); - #endif /* EFA_RDM_PEER_H */ diff --git a/prov/efa/src/rdm/efa_rdm_pke_rtm.c b/prov/efa/src/rdm/efa_rdm_pke_rtm.c index cd9939d85d7..6dc4676e1af 100644 --- a/prov/efa/src/rdm/efa_rdm_pke_rtm.c +++ b/prov/efa/src/rdm/efa_rdm_pke_rtm.c @@ -1340,16 +1340,13 @@ void efa_rdm_pke_handle_runtread_rtm_sent(struct efa_rdm_pke *pkt_entry) { struct efa_rdm_ep *ep; struct efa_rdm_ope *txe; - struct efa_rdm_peer *peer; size_t pkt_data_size = pkt_entry->payload_size; ep = pkt_entry->ep; - peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr); - assert(peer); txe = pkt_entry->ope; txe->bytes_sent += pkt_data_size; - peer->num_runt_bytes_in_flight += pkt_data_size; + efa_rdm_ep_domain(ep)->num_runt_bytes_in_flight += pkt_data_size; if (efa_rdm_pke_get_runtread_rtm_base_hdr(pkt_entry)->seg_offset == 0 && txe->total_len > txe->bytes_runt) @@ -1368,7 +1365,6 @@ void efa_rdm_pke_handle_runtread_rtm_send_completion(struct efa_rdm_pke *pkt_ent { struct efa_rdm_ep *ep; struct efa_rdm_ope *txe; - struct efa_rdm_peer *peer; size_t pkt_data_size; ep = pkt_entry->ep; @@ -1376,10 +1372,8 @@ void efa_rdm_pke_handle_runtread_rtm_send_completion(struct efa_rdm_pke *pkt_ent pkt_data_size = pkt_entry->payload_size; txe->bytes_acked += pkt_data_size; - peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr); - assert(peer); - assert(peer->num_runt_bytes_in_flight >= pkt_data_size); - peer->num_runt_bytes_in_flight -= pkt_data_size; + assert(efa_rdm_ep_domain(ep)->num_runt_bytes_in_flight >= pkt_data_size); + efa_rdm_ep_domain(ep)->num_runt_bytes_in_flight -= pkt_data_size; if (txe->total_len == txe->bytes_acked) efa_rdm_ope_handle_send_completed(txe); } diff --git a/prov/efa/test/efa_unit_test_runt.c b/prov/efa/test/efa_unit_test_runt.c index 9bb23a2d7bd..d36da629845 100644 --- a/prov/efa/test/efa_unit_test_runt.c +++ b/prov/efa/test/efa_unit_test_runt.c @@ -4,25 +4,24 @@ #include "efa_unit_tests.h" /** - * @brief Test the runt size returned by efa_rdm_peer_get_runt_size + * @brief Test the runt size returned by efa_rdm_ep_get_runt_size * * @param resource efa_resource * @param iface hmem iface - * @param peer_num_runt_bytes_in_flight how many runt bytes are in flight on the peer side + * @param num_runt_bytes_in_flight how many runt bytes are in flight on the peer side * @param total_runt_size the total runt size * @param total_len the total length of the message to be sent * @param expected_runt_size the expected runt size */ static -void test_efa_rdm_peer_get_runt_size_impl( +void test_efa_rdm_ep_get_runt_size_impl( struct efa_resource *resource, - enum fi_hmem_iface iface, size_t peer_num_runt_bytes_in_flight, + enum fi_hmem_iface iface, size_t num_runt_bytes_in_flight, size_t total_runt_size, size_t total_len, size_t expected_runt_size) { struct efa_rdm_ep *efa_rdm_ep; struct efa_ep_addr raw_addr; size_t raw_addr_len = sizeof(raw_addr); - struct efa_rdm_peer *peer; fi_addr_t addr; struct efa_mr mock_mr; struct efa_rdm_ope mock_txe; @@ -41,8 +40,7 @@ void test_efa_rdm_peer_get_runt_size_impl( raw_addr.qkey = 0x1234; ret = fi_av_insert(resource->av, &raw_addr, 1, &addr, 0 /* flags */, NULL /* context */); assert_int_equal(ret, 1); - peer = efa_rdm_ep_get_peer(efa_rdm_ep, addr); - peer->num_runt_bytes_in_flight = peer_num_runt_bytes_in_flight; + efa_domain->num_runt_bytes_in_flight = num_runt_bytes_in_flight; mock_mr.peer.iface = iface; @@ -51,142 +49,142 @@ void test_efa_rdm_peer_get_runt_size_impl( mock_txe.addr = addr; mock_txe.desc[0] = &mock_mr; - runt_size = efa_rdm_peer_get_runt_size(peer, efa_rdm_ep, &mock_txe); + runt_size = efa_rdm_ep_get_runt_size(efa_rdm_ep, &mock_txe); assert_true(runt_size == expected_runt_size); } -void test_efa_rdm_peer_get_runt_size_no_enough_runt(struct efa_resource **state) +void test_efa_rdm_ep_get_runt_size_no_enough_runt(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; size_t expected_runt_size; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 12000; - peer_num_runt_bytes_in_flight = 1001; + num_runt_bytes_in_flight = 1001; total_runt_size = 1000; /* 1001 is exceeding 1000, cannot runt */ expected_runt_size = 0; - test_efa_rdm_peer_get_runt_size_impl(resource, FI_HMEM_SYSTEM, peer_num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); + test_efa_rdm_ep_get_runt_size_impl(resource, FI_HMEM_SYSTEM, num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); } -void test_efa_rdm_peer_get_runt_size_cuda_memory_smaller_than_alignment(struct efa_resource **state) +void test_efa_rdm_ep_get_runt_size_cuda_memory_smaller_than_alignment(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; size_t expected_runt_size; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 12000; - peer_num_runt_bytes_in_flight = 1000; + num_runt_bytes_in_flight = 1000; total_runt_size = 1048; /* 1048 - 1000 is smaller than cuda memory alignment (64), runt size must be 0 */ expected_runt_size = 0; - test_efa_rdm_peer_get_runt_size_impl(resource, FI_HMEM_CUDA, peer_num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); + test_efa_rdm_ep_get_runt_size_impl(resource, FI_HMEM_CUDA, num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); } -void test_efa_rdm_peer_get_runt_size_cuda_memory_exceeding_total_len(struct efa_resource **state) +void test_efa_rdm_ep_get_runt_size_cuda_memory_exceeding_total_len(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; size_t expected_runt_size; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 12000; - peer_num_runt_bytes_in_flight = 0; + num_runt_bytes_in_flight = 0; total_runt_size = 16384; /* 16384 - 0 is exceeding 12000 (total_len), runt size must be 12000 // 64 * 64 = 11968 */ expected_runt_size = 11968; - test_efa_rdm_peer_get_runt_size_impl(resource, FI_HMEM_CUDA, peer_num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); + test_efa_rdm_ep_get_runt_size_impl(resource, FI_HMEM_CUDA, num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); } -void test_efa_rdm_peer_get_runt_size_cuda_memory_normal(struct efa_resource **state) +void test_efa_rdm_ep_get_runt_size_cuda_memory_normal(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; size_t expected_runt_size; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 12000; - peer_num_runt_bytes_in_flight = 10000; + num_runt_bytes_in_flight = 10000; total_runt_size = 16384; /* 16384 - 10000 is smaller than 12000 (total_len), runt size must be (16384 - 10000) // 64 * 64 = 6336 */ expected_runt_size = 6336; - test_efa_rdm_peer_get_runt_size_impl(resource, FI_HMEM_CUDA, peer_num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); + test_efa_rdm_ep_get_runt_size_impl(resource, FI_HMEM_CUDA, num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); } -void test_efa_rdm_peer_get_runt_size_host_memory_smaller_than_alignment(struct efa_resource **state) +void test_efa_rdm_ep_get_runt_size_host_memory_smaller_than_alignment(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; size_t expected_runt_size; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 12000; - peer_num_runt_bytes_in_flight = 1000; + num_runt_bytes_in_flight = 1000; total_runt_size = 1004; /* 1004 - 1000 is smaller than host memory alignment (8), runt size must be 0 */ expected_runt_size = 0; - test_efa_rdm_peer_get_runt_size_impl(resource, FI_HMEM_SYSTEM, peer_num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); + test_efa_rdm_ep_get_runt_size_impl(resource, FI_HMEM_SYSTEM, num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); } -void test_efa_rdm_peer_get_runt_size_host_memory_exceeding_total_len(struct efa_resource **state) +void test_efa_rdm_ep_get_runt_size_host_memory_exceeding_total_len(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; size_t expected_runt_size; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 1111; - peer_num_runt_bytes_in_flight = 0; + num_runt_bytes_in_flight = 0; total_runt_size = 16384; /* 16384 - 0 is exceeding 1111 (total_len), runt size must be 1111 // 8 * 8 = 1104 */ expected_runt_size = 1104; - test_efa_rdm_peer_get_runt_size_impl(resource, FI_HMEM_SYSTEM, peer_num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); + test_efa_rdm_ep_get_runt_size_impl(resource, FI_HMEM_SYSTEM, num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); } -void test_efa_rdm_peer_get_runt_size_host_memory_normal(struct efa_resource **state) +void test_efa_rdm_ep_get_runt_size_host_memory_normal(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; size_t expected_runt_size; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 12000; - peer_num_runt_bytes_in_flight = 10000; + num_runt_bytes_in_flight = 10000; total_runt_size = 11111; /* 11111 - 10000 is smaller than 12000 (total_len), runt size must be (11111 - 10000) // 8 * 8 = 1104 */ expected_runt_size = 1104; - test_efa_rdm_peer_get_runt_size_impl(resource, FI_HMEM_SYSTEM, peer_num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); + test_efa_rdm_ep_get_runt_size_impl(resource, FI_HMEM_SYSTEM, num_runt_bytes_in_flight, total_runt_size, msg_length, expected_runt_size); } /** - * @brief Test the protocol returned by efa_rdm_peer_select_readbase_rtm() + * @brief Test the protocol returned by efa_rdm_ep_select_readbase_rtm() * * @param resource efa test resources * @param iface hmem iface - * @param peer_num_runt_bytes_in_flight how many runt bytes are in flight on the peer side + * @param num_runt_bytes_in_flight how many runt bytes are in flight on the peer side * @param total_runt_size the total runt size * @param total_len the total length of the message to be sent * @param op the operational code (ofi_op_msg or ofi_op_tag) @@ -194,16 +192,15 @@ void test_efa_rdm_peer_get_runt_size_host_memory_normal(struct efa_resource **st * @param expected_protocol the expected protocol to be selected */ static -void test_efa_rdm_peer_select_readbase_rtm_impl( +void test_efa_rdm_ep_select_readbase_rtm_impl( struct efa_resource *resource, - enum fi_hmem_iface iface, size_t peer_num_runt_bytes_in_flight, + enum fi_hmem_iface iface, size_t num_runt_bytes_in_flight, size_t total_runt_size, size_t total_len, int op, uint64_t fi_flags, int expected_protocol) { struct efa_rdm_ep *efa_rdm_ep; struct efa_ep_addr raw_addr; size_t raw_addr_len = sizeof(raw_addr); - struct efa_rdm_peer *peer; fi_addr_t addr; struct efa_mr mock_mr; struct efa_rdm_ope mock_txe; @@ -222,8 +219,7 @@ void test_efa_rdm_peer_select_readbase_rtm_impl( raw_addr.qkey = 0x1234; ret = fi_av_insert(resource->av, &raw_addr, 1, &addr, 0 /* flags */, NULL /* context */); assert_int_equal(ret, 1); - peer = efa_rdm_ep_get_peer(efa_rdm_ep, addr); - peer->num_runt_bytes_in_flight = peer_num_runt_bytes_in_flight; + efa_domain->num_runt_bytes_in_flight = num_runt_bytes_in_flight; mock_mr.peer.iface = iface; @@ -234,40 +230,40 @@ void test_efa_rdm_peer_select_readbase_rtm_impl( mock_txe.op = op; mock_txe.fi_flags = fi_flags; - readbase_rtm = efa_rdm_peer_select_readbase_rtm(peer, efa_rdm_ep, &mock_txe); + readbase_rtm = efa_rdm_ep_select_readbase_rtm(efa_rdm_ep, &mock_txe); assert_true(readbase_rtm == expected_protocol); } -void test_efa_rdm_peer_select_readbase_rtm_no_runt(struct efa_resource **state) +void test_efa_rdm_ep_select_readbase_rtm_no_runt(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 12000; - peer_num_runt_bytes_in_flight = 1000; + num_runt_bytes_in_flight = 1000; total_runt_size = 1048; /* 1048 - 1000 is smaller than cuda memory alignment, runt size must be 0, use long read protocol */ - test_efa_rdm_peer_select_readbase_rtm_impl(resource, FI_HMEM_CUDA, peer_num_runt_bytes_in_flight, + test_efa_rdm_ep_select_readbase_rtm_impl(resource, FI_HMEM_CUDA, num_runt_bytes_in_flight, total_runt_size, msg_length, ofi_op_msg, 0, EFA_RDM_LONGREAD_MSGRTM_PKT); } -void test_efa_rdm_peer_select_readbase_rtm_do_runt(struct efa_resource **state) +void test_efa_rdm_ep_select_readbase_rtm_do_runt(struct efa_resource **state) { struct efa_resource *resource = *state; size_t msg_length; - size_t peer_num_runt_bytes_in_flight; + size_t num_runt_bytes_in_flight; size_t total_runt_size; efa_unit_test_resource_construct(resource, FI_EP_RDM); msg_length = 12000; - peer_num_runt_bytes_in_flight = 1000; + num_runt_bytes_in_flight = 1000; total_runt_size = 2000; /* 2000 - 1000 is larger than cuda memory alignment, should use runt read protocol */ - test_efa_rdm_peer_select_readbase_rtm_impl(resource, FI_HMEM_CUDA, peer_num_runt_bytes_in_flight, + test_efa_rdm_ep_select_readbase_rtm_impl(resource, FI_HMEM_CUDA, num_runt_bytes_in_flight, total_runt_size, msg_length, ofi_op_msg, 0, EFA_RDM_RUNTREAD_MSGRTM_PKT); } \ No newline at end of file diff --git a/prov/efa/test/efa_unit_tests.c b/prov/efa/test/efa_unit_tests.c index fe075e57919..c0c32f891c7 100644 --- a/prov/efa/test/efa_unit_tests.c +++ b/prov/efa/test/efa_unit_tests.c @@ -149,14 +149,14 @@ int main(void) cmocka_unit_test_setup_teardown(test_efa_rdm_msg_send_to_local_peer_with_null_desc, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), cmocka_unit_test_setup_teardown(test_efa_fork_support_request_initialize_when_ibv_fork_support_is_needed, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), cmocka_unit_test_setup_teardown(test_efa_fork_support_request_initialize_when_ibv_fork_support_is_unneeded, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), - cmocka_unit_test_setup_teardown(test_efa_rdm_peer_get_runt_size_no_enough_runt, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), - cmocka_unit_test_setup_teardown(test_efa_rdm_peer_get_runt_size_cuda_memory_smaller_than_alignment, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), - cmocka_unit_test_setup_teardown(test_efa_rdm_peer_get_runt_size_cuda_memory_exceeding_total_len, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), - cmocka_unit_test_setup_teardown(test_efa_rdm_peer_get_runt_size_cuda_memory_normal, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), - cmocka_unit_test_setup_teardown(test_efa_rdm_peer_get_runt_size_host_memory_exceeding_total_len, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), - cmocka_unit_test_setup_teardown(test_efa_rdm_peer_get_runt_size_host_memory_normal, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), - cmocka_unit_test_setup_teardown(test_efa_rdm_peer_select_readbase_rtm_no_runt, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), - cmocka_unit_test_setup_teardown(test_efa_rdm_peer_select_readbase_rtm_do_runt, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), + cmocka_unit_test_setup_teardown(test_efa_rdm_ep_get_runt_size_no_enough_runt, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), + cmocka_unit_test_setup_teardown(test_efa_rdm_ep_get_runt_size_cuda_memory_smaller_than_alignment, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), + cmocka_unit_test_setup_teardown(test_efa_rdm_ep_get_runt_size_cuda_memory_exceeding_total_len, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), + cmocka_unit_test_setup_teardown(test_efa_rdm_ep_get_runt_size_cuda_memory_normal, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), + cmocka_unit_test_setup_teardown(test_efa_rdm_ep_get_runt_size_host_memory_exceeding_total_len, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), + cmocka_unit_test_setup_teardown(test_efa_rdm_ep_get_runt_size_host_memory_normal, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), + cmocka_unit_test_setup_teardown(test_efa_rdm_ep_select_readbase_rtm_no_runt, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), + cmocka_unit_test_setup_teardown(test_efa_rdm_ep_select_readbase_rtm_do_runt, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), cmocka_unit_test_setup_teardown(test_efa_domain_open_ops_wrong_name, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), cmocka_unit_test_setup_teardown(test_efa_domain_open_ops_mr_query, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), cmocka_unit_test_setup_teardown(test_efa_rdm_cq_ibv_cq_poll_list_same_tx_rx_cq_single_ep, efa_unit_test_mocks_setup, efa_unit_test_mocks_teardown), diff --git a/prov/efa/test/efa_unit_tests.h b/prov/efa/test/efa_unit_tests.h index 07259f285ed..4de59db9e4d 100644 --- a/prov/efa/test/efa_unit_tests.h +++ b/prov/efa/test/efa_unit_tests.h @@ -162,15 +162,15 @@ void test_efa_rdm_ope_post_write_0_byte(); void test_efa_rdm_msg_send_to_local_peer_with_null_desc(); void test_efa_fork_support_request_initialize_when_ibv_fork_support_is_needed(); void test_efa_fork_support_request_initialize_when_ibv_fork_support_is_unneeded(); -void test_efa_rdm_peer_get_runt_size_no_enough_runt(); -void test_efa_rdm_peer_get_runt_size_cuda_memory_smaller_than_alignment(); -void test_efa_rdm_peer_get_runt_size_cuda_memory_exceeding_total_len(); -void test_efa_rdm_peer_get_runt_size_cuda_memory_normal(); -void test_efa_rdm_peer_get_runt_size_host_memory_smaller_than_alignment(); -void test_efa_rdm_peer_get_runt_size_host_memory_exceeding_total_len(); -void test_efa_rdm_peer_get_runt_size_host_memory_normal(); -void test_efa_rdm_peer_select_readbase_rtm_no_runt(); -void test_efa_rdm_peer_select_readbase_rtm_do_runt(); +void test_efa_rdm_ep_get_runt_size_no_enough_runt(); +void test_efa_rdm_ep_get_runt_size_cuda_memory_smaller_than_alignment(); +void test_efa_rdm_ep_get_runt_size_cuda_memory_exceeding_total_len(); +void test_efa_rdm_ep_get_runt_size_cuda_memory_normal(); +void test_efa_rdm_ep_get_runt_size_host_memory_smaller_than_alignment(); +void test_efa_rdm_ep_get_runt_size_host_memory_exceeding_total_len(); +void test_efa_rdm_ep_get_runt_size_host_memory_normal(); +void test_efa_rdm_ep_select_readbase_rtm_no_runt(); +void test_efa_rdm_ep_select_readbase_rtm_do_runt(); void test_efa_domain_open_ops_wrong_name(); void test_efa_domain_open_ops_mr_query(); void test_efa_rdm_cq_ibv_cq_poll_list_same_tx_rx_cq_single_ep();