diff --git a/prov/efa/Makefile.include b/prov/efa/Makefile.include index 5886f121929..538e778c81f 100644 --- a/prov/efa/Makefile.include +++ b/prov/efa/Makefile.include @@ -142,7 +142,9 @@ nodist_prov_efa_test_efa_unit_test_SOURCES = \ prov/efa/test/efa_unit_test_rnr.c \ prov/efa/test/efa_unit_test_ope.c \ prov/efa/test/efa_unit_test_send.c \ - prov/efa/test/efa_unit_test_fork_support.c + prov/efa/test/efa_unit_test_fork_support.c \ + prov/efa/test/efa_unit_test_runt.c + efa_CPPFLAGS += -I$(top_srcdir)/include -I$(top_srcdir)/prov/efa/test $(cmocka_CPPFLAGS) diff --git a/prov/efa/src/efa.h b/prov/efa/src/efa.h index 03ecec8b219..ae3756ca468 100644 --- a/prov/efa/src/efa.h +++ b/prov/efa/src/efa.h @@ -106,6 +106,11 @@ #define EFA_DEFAULT_INTER_MIN_READ_WRITE_SIZE (65536) #define EFA_DEFAULT_INTRA_MAX_GDRCOPY_FROM_DEV_SIZE (3072) +/* + * The default memory alignment + */ +#define EFA_RDM_DEFAULT_MEMORY_ALIGNMENT (8) + /* * The CUDA memory alignment */ diff --git a/prov/efa/src/rdm/efa_rdm_ep.h b/prov/efa/src/rdm/efa_rdm_ep.h index 2ecd9f51c06..18a915928e6 100644 --- a/prov/efa/src/rdm/efa_rdm_ep.h +++ b/prov/efa/src/rdm/efa_rdm_ep.h @@ -302,6 +302,8 @@ void efa_rdm_ep_queue_rnr_pkt(struct efa_rdm_ep *ep, ssize_t efa_rdm_ep_post_queued_pkts(struct efa_rdm_ep *ep, struct dlist_entry *pkts); +size_t efa_rdm_ep_get_memory_alignment(struct efa_rdm_ep *ep, enum fi_hmem_iface iface); + 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 1f3f4c57767..761b9c66705 100644 --- a/prov/efa/src/rdm/efa_rdm_ep_utils.c +++ b/prov/efa/src/rdm/efa_rdm_ep_utils.c @@ -673,3 +673,23 @@ void efa_rdm_ep_post_handshake_or_queue(struct efa_rdm_ep *ep, struct efa_rdm_pe peer->flags |= EFA_RDM_PEER_HANDSHAKE_SENT; } + +/** + * @brief Get memory alignment for given ep and hmem iface + * + * @param ep efa rdm ep + * @param iface hmem iface + * @return size_t the memory alignment + */ +size_t efa_rdm_ep_get_memory_alignment(struct efa_rdm_ep *ep, enum fi_hmem_iface iface) +{ + size_t memory_alignment = EFA_RDM_DEFAULT_MEMORY_ALIGNMENT; + + if (ep->sendrecv_in_order_aligned_128_bytes) { + memory_alignment = EFA_RDM_IN_ORDER_ALIGNMENT; + } else if (iface == FI_HMEM_CUDA) { + memory_alignment = EFA_RDM_CUDA_MEMORY_ALIGNMENT; + } + + return memory_alignment; +} diff --git a/prov/efa/src/rdm/efa_rdm_msg.c b/prov/efa/src/rdm/efa_rdm_msg.c index 292becbbda2..4e66bcf39d3 100644 --- a/prov/efa/src/rdm/efa_rdm_msg.c +++ b/prov/efa/src/rdm/efa_rdm_msg.c @@ -90,7 +90,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(peer, txe->op, txe->fi_flags, &hmem_info[iface]); + readbase_rtm = efa_rdm_peer_select_readbase_rtm(peer, efa_rdm_ep, txe); if (txe->total_len >= hmem_info[iface].min_read_msg_size && efa_rdm_interop_rdma_read(efa_rdm_ep, peer) && diff --git a/prov/efa/src/rdm/efa_rdm_ope.c b/prov/efa/src/rdm/efa_rdm_ope.c index 5d2e0af71aa..60fee5631be 100644 --- a/prov/efa/src/rdm/efa_rdm_ope.c +++ b/prov/efa/src/rdm/efa_rdm_ope.c @@ -354,8 +354,6 @@ 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) { - int iface; - struct efa_hmem_info *hmem_info; struct efa_rdm_peer *peer; assert(txe->type == EFA_RDM_TXE); @@ -365,11 +363,10 @@ void efa_rdm_txe_set_runt_size(struct efa_rdm_ep *ep, struct efa_rdm_ope *txe) peer = efa_rdm_ep_get_peer(ep, txe->addr); - iface = txe->desc[0] ? ((struct efa_mr*) txe->desc[0])->peer.iface : FI_HMEM_SYSTEM; - hmem_info = &efa_rdm_ep_domain(ep)->hmem_info[iface]; - assert(peer); - txe->bytes_runt = MIN(hmem_info->runt_size - peer->num_runt_bytes_in_flight, txe->total_len); + txe->bytes_runt = efa_rdm_peer_get_runt_size(peer, ep, txe); + + assert(txe->bytes_runt); } /** @@ -481,7 +478,7 @@ ssize_t efa_rdm_ope_prepare_to_post_send(struct efa_rdm_ope *ope, size_t total_pkt_entry_data_size; /* total number of bytes send via packet entry's payload */ size_t single_pkt_entry_data_size; size_t single_pkt_entry_max_data_size; - int i, memory_alignment = 8, remainder; + int i, memory_alignment, remainder, iface; int available_tx_pkts; ep = ope->ep; @@ -520,11 +517,8 @@ ssize_t efa_rdm_ope_prepare_to_post_send(struct efa_rdm_ope *ope, single_pkt_entry_max_data_size = efa_rdm_txe_max_req_data_capacity(ep, ope, pkt_type); assert(single_pkt_entry_max_data_size); - if (ep->sendrecv_in_order_aligned_128_bytes) { - memory_alignment = EFA_RDM_IN_ORDER_ALIGNMENT; - } else if (efa_mr_is_cuda(ope->desc[0])) { - memory_alignment = EFA_RDM_CUDA_MEMORY_ALIGNMENT; - } + iface = ope->desc[0] ? ((struct efa_mr*) ope->desc[0])->peer.iface : FI_HMEM_SYSTEM; + memory_alignment = efa_rdm_ep_get_memory_alignment(ep, iface); *pkt_entry_cnt = (total_pkt_entry_data_size - 1) / single_pkt_entry_max_data_size + 1; if (*pkt_entry_cnt > available_tx_pkts) @@ -537,6 +531,8 @@ ssize_t efa_rdm_ope_prepare_to_post_send(struct efa_rdm_ope *ope, /* each packet must be aligned */ single_pkt_entry_data_size = single_pkt_entry_data_size & ~(memory_alignment - 1); + assert(single_pkt_entry_data_size); + *pkt_entry_cnt = total_pkt_entry_data_size / single_pkt_entry_data_size; for (i = 0; i < *pkt_entry_cnt; ++i) pkt_entry_data_size_vec[i] = single_pkt_entry_data_size; diff --git a/prov/efa/src/rdm/efa_rdm_peer.c b/prov/efa/src/rdm/efa_rdm_peer.c index 019ea6b6a7c..34b810580ca 100644 --- a/prov/efa/src/rdm/efa_rdm_peer.c +++ b/prov/efa/src/rdm/efa_rdm_peer.c @@ -254,21 +254,57 @@ 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] op operation type - * @param[in] flags the flags that the application used to call fi_* functions - * @param[in] hmem_info configured protocol limits + * @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, int op, uint64_t fi_flags, struct efa_hmem_info *hmem_info) +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 (peer->num_read_msg_in_flight == 0 && - hmem_info->runt_size > peer->num_runt_bytes_in_flight && - !(fi_flags & FI_DELIVERY_COMPLETE)) { + 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 { diff --git a/prov/efa/src/rdm/efa_rdm_peer.h b/prov/efa/src/rdm/efa_rdm_peer.h index 1a42174d943..687f3d62340 100644 --- a/prov/efa/src/rdm/efa_rdm_peer.h +++ b/prov/efa/src/rdm/efa_rdm_peer.h @@ -251,6 +251,8 @@ 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); -int efa_rdm_peer_select_readbase_rtm(struct efa_rdm_peer *peer, int op, uint64_t fi_flags, struct efa_hmem_info *hmem_info); +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/test/efa_unit_test_runt.c b/prov/efa/test/efa_unit_test_runt.c new file mode 100644 index 00000000000..9c2824c45e8 --- /dev/null +++ b/prov/efa/test/efa_unit_test_runt.c @@ -0,0 +1,270 @@ +#include "efa_unit_tests.h" + +/** + * @brief Test the runt size returned by efa_rdm_peer_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 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( + struct efa_resource *resource, + enum fi_hmem_iface iface, size_t peer_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; + size_t runt_size; + struct efa_domain *efa_domain; + int ret; + + efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid); + efa_domain = efa_rdm_ep_domain(efa_rdm_ep); + efa_domain->hmem_info[iface].runt_size = total_runt_size; + + /* insert a fake peer */ + ret = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len); + assert_int_equal(ret, 0); + raw_addr.qpn = 1; + 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; + + mock_mr.peer.iface = iface; + + memset(&mock_txe, 0, sizeof(mock_txe)); + mock_txe.total_len = total_len; + mock_txe.addr = addr; + mock_txe.desc[0] = &mock_mr; + + runt_size = efa_rdm_peer_get_runt_size(peer, 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) +{ + struct efa_resource *resource = *state; + size_t msg_length; + size_t expected_runt_size; + size_t peer_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; + 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); +} + +void test_efa_rdm_peer_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 total_runt_size; + + efa_unit_test_resource_construct(resource, FI_EP_RDM); + + msg_length = 12000; + peer_num_runt_bytes_in_flight = 1000; + total_runt_size = 1048; + /* 1048 - 1000 is smaller than cuda memory alignment, 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); +} + +void test_efa_rdm_peer_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 total_runt_size; + + efa_unit_test_resource_construct(resource, FI_EP_RDM); + + msg_length = 12000; + peer_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); +} + +void test_efa_rdm_peer_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 total_runt_size; + + efa_unit_test_resource_construct(resource, FI_EP_RDM); + + msg_length = 12000; + peer_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); +} + +void test_efa_rdm_peer_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 total_runt_size; + + efa_unit_test_resource_construct(resource, FI_EP_RDM); + + msg_length = 12000; + peer_num_runt_bytes_in_flight = 1000; + total_runt_size = 1004; + /* 1048 - 1000 is smaller than host memory alignment, 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); +} + +void test_efa_rdm_peer_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 total_runt_size; + + efa_unit_test_resource_construct(resource, FI_EP_RDM); + + msg_length = 1111; + peer_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); +} + +void test_efa_rdm_peer_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 total_runt_size; + + efa_unit_test_resource_construct(resource, FI_EP_RDM); + + msg_length = 12000; + peer_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); +} + +/** + * @brief Test the protocol returned by efa_rdm_peer_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 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) + * @param fi_flags the op flags of the send operations + * @param expected_protocol the expected protocol to be selected + */ +static +void test_efa_rdm_peer_select_readbase_rtm_impl( + struct efa_resource *resource, + enum fi_hmem_iface iface, size_t peer_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; + struct efa_domain *efa_domain; + int readbase_rtm; + int ret; + + efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid); + efa_domain = efa_rdm_ep_domain(efa_rdm_ep); + efa_domain->hmem_info[iface].runt_size = total_runt_size; + + /* insert a fake peer */ + ret = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len); + assert_int_equal(ret, 0); + raw_addr.qpn = 1; + 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; + + mock_mr.peer.iface = iface; + + memset(&mock_txe, 0, sizeof(mock_txe)); + mock_txe.total_len = total_len; + mock_txe.addr = addr; + mock_txe.desc[0] = &mock_mr; + mock_txe.op = op; + mock_txe.fi_flags = fi_flags; + + readbase_rtm = efa_rdm_peer_select_readbase_rtm(peer, 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) +{ + struct efa_resource *resource = *state; + size_t msg_length; + size_t peer_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; + 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, + 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) +{ + struct efa_resource *resource = *state; + size_t msg_length; + size_t peer_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; + 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, + 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 1091d4540ff..97fadead2e6 100644 --- a/prov/efa/test/efa_unit_tests.c +++ b/prov/efa/test/efa_unit_tests.c @@ -133,6 +133,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_set_message_output(CM_OUTPUT_XML); diff --git a/prov/efa/test/efa_unit_tests.h b/prov/efa/test/efa_unit_tests.h index dc5b01c664d..c0f15f42729 100644 --- a/prov/efa/test/efa_unit_tests.h +++ b/prov/efa/test/efa_unit_tests.h @@ -141,5 +141,14 @@ 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(); #endif