From 2100e23ec8b73af382b9e42ec8f96a9b07490ecd Mon Sep 17 00:00:00 2001 From: 23-Wzz <906152691@qq.com> Date: Mon, 28 Jun 2021 10:28:23 +0800 Subject: [PATCH] Delete Chenge's MR --- src/tools/info/group_info.c | 13 +++ src/ucp/core/ucp_context.h | 1 - src/ucp/core/ucp_types.h | 2 +- src/ucp/core/ucp_worker.c | 10 +- src/ucs/datastruct/ptr_array.c | 2 +- test/gtest/ucg/test_builtin.cc | 150 +++++++++++++++---------- test/gtest/ucg/test_cb.cc | 156 +++++--------------------- test/gtest/ucg/test_coll_algorithm.cc | 105 ++++++++--------- test/gtest/ucg/test_collective.cc | 18 ++- test/gtest/ucg/test_group.cc | 10 +- test/gtest/ucg/test_op.cc | 44 +++----- test/gtest/ucg/test_op.h | 2 - test/gtest/ucg/test_plan.cc | 79 +++++++------ test/gtest/ucg/test_step.cc | 41 +++---- test/gtest/ucg/test_topo_info.cc | 4 +- test/gtest/ucg/test_ucg_context.cc | 42 +++---- test/gtest/ucg/ucg_plan_test.h | 4 +- test/gtest/ucg/ucg_test.cc | 148 ++++++++---------------- test/gtest/ucg/ucg_test.h | 17 +-- test/gtest/uct/test_fence.cc | 4 +- 20 files changed, 347 insertions(+), 505 deletions(-) diff --git a/src/tools/info/group_info.c b/src/tools/info/group_info.c index 66c5b2482dc..a01ffc8889b 100644 --- a/src/tools/info/group_info.c +++ b/src/tools/info/group_info.c @@ -7,6 +7,7 @@ #include "ucx_info.h" #include +#include #include #include @@ -22,3 +23,15 @@ const char *collective_names[] = { }; #define EMPTY UCG_GROUP_MEMBER_DISTANCE_LAST + +ucg_address_t *worker_address = 0; +ucs_status_t dummy_resolve_address(void *cb_group_obj, + ucg_group_member_index_t index, + ucg_address_t **addr, size_t *addr_len) +{ + *addr = worker_address; + *addr_len = 0; /* special debug flow: replace uct_ep_t with member indexes */ + return UCS_OK; +} + +void dummy_release_address(ucg_address_t *addr) { } \ No newline at end of file diff --git a/src/ucp/core/ucp_context.h b/src/ucp/core/ucp_context.h index 5d3b8908816..ef6e2d84ec6 100644 --- a/src/ucp/core/ucp_context.h +++ b/src/ucp/core/ucp_context.h @@ -269,7 +269,6 @@ typedef struct ucp_am_handler { ucp_am_tracer_t tracer; uint32_t flags; uct_am_callback_t proxy_cb; - void *alt_arg; /**< Alternative argument for cb */ } ucp_am_handler_t; typedef struct ucp_tl_iface_atomic_flags { diff --git a/src/ucp/core/ucp_types.h b/src/ucp/core/ucp_types.h index d5058ad7637..c3920c33182 100644 --- a/src/ucp/core/ucp_types.h +++ b/src/ucp/core/ucp_types.h @@ -97,7 +97,7 @@ enum { UCP_AM_ID_SINGLE_REPLY = 26, /* Single fragment user defined AM carrying remote ep for reply */ UCP_AM_ID_LAST, - UCP_AM_ID_MAX = UCT_AM_ID_MAX /* Total IDs available for pre-registration */ + UCP_AM_ID_MAX = 32 /* Total IDs available for pre-registration */ }; diff --git a/src/ucp/core/ucp_worker.c b/src/ucp/core/ucp_worker.c index 299794b25ce..46599237930 100644 --- a/src/ucp/core/ucp_worker.c +++ b/src/ucp/core/ucp_worker.c @@ -140,12 +140,11 @@ static void ucp_worker_set_am_handlers(ucp_worker_iface_t *wiface, int is_proxy) ucp_context_h context = worker->context; ucs_status_t status; unsigned am_id; - void *cb_arg; ucs_trace_func("iface=%p is_proxy=%d", wiface->iface, is_proxy); for (am_id = 0; am_id < UCP_AM_ID_MAX; ++am_id) { - if (!is_proxy && ucp_am_handlers[am_id].cb == NULL) { + if (!ucp_am_handlers[am_id].cb) { continue; } @@ -179,14 +178,9 @@ static void ucp_worker_set_am_handlers(ucp_worker_iface_t *wiface, int is_proxy) wiface, ucp_am_handlers[am_id].flags); } else { - if (ucp_am_handlers[am_id].alt_arg != NULL) { - cb_arg = ucp_am_handlers[am_id].alt_arg; - } else { - cb_arg = worker; - } status = uct_iface_set_am_handler(wiface->iface, am_id, ucp_am_handlers[am_id].cb, - cb_arg, + worker, ucp_am_handlers[am_id].flags); } if (status != UCS_OK) { diff --git a/src/ucs/datastruct/ptr_array.c b/src/ucs/datastruct/ptr_array.c index d8f9cce11ce..691281bddf2 100644 --- a/src/ucs/datastruct/ptr_array.c +++ b/src/ucs/datastruct/ptr_array.c @@ -209,7 +209,7 @@ void ucs_ptr_array_set(ucs_ptr_array_t *ptr_array, unsigned element_index, ucs_ptr_array_elem_t *elem; unsigned next, free_iter, free_ahead, new_size; - if (ucs_unlikely(element_index >= ptr_array->size)) { + if (ucs_unlikely(element_index > ptr_array->size)) { new_size = ucs_max(ptr_array->size * 2, element_index + 1); ucs_ptr_array_grow(ptr_array, new_size UCS_MEMTRACK_NAME(ptr_array->name)); } else if (!__ucs_ptr_array_is_free(ptr_array->start[element_index])) { diff --git a/test/gtest/ucg/test_builtin.cc b/test/gtest/ucg/test_builtin.cc index 9d149d98170..f4a8144b289 100644 --- a/test/gtest/ucg/test_builtin.cc +++ b/test/gtest/ucg/test_builtin.cc @@ -9,32 +9,30 @@ extern "C" { #include "ucg_test.h" #include "ucg_plan_test.h" + ucg_plan_test::ucg_plan_test() { m_builtin_ctx = NULL; + m_planc = NULL; m_group_params = NULL; m_coll_params = NULL; m_group = NULL; - m_planner_p = NULL; m_all_rank_infos.clear(); } ucg_plan_test::ucg_plan_test(size_t node_cnt, size_t ppn, unsigned myrank) { + m_planc = NULL; m_all_rank_infos.clear(); m_resource_factory->create_balanced_rank_info(m_all_rank_infos, node_cnt, ppn); - m_group_params = m_resource_factory->create_group_params(m_all_rank_infos[myrank], m_all_rank_infos, m_ucp_worker); - m_resource_factory->create_group(m_group_params, m_ucg_context, &m_group); + m_group_params = m_resource_factory->create_group_params(m_all_rank_infos[myrank], m_all_rank_infos); + m_group = m_resource_factory->create_group(m_group_params, m_ucg_worker); m_coll_params = m_resource_factory->create_collective_params(UCG_GROUP_COLLECTIVE_MODIFIER_SINGLE_SOURCE, 0, NULL, 1, NULL, 4, NULL, NULL); m_coll_type.modifiers = UCG_GROUP_COLLECTIVE_MODIFIER_AGGREGATE; m_coll_type.root = 0; - - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucg_group_select_planner(m_group, NULL, m_coll_params, &planner, &planner_ctx); - ucg_builtin_component.query(&m_planner_p); - m_builtin_ctx = (ucg_builtin_planner_ctx_t *)planner_ctx; + ucg_plan_select(m_group, NULL, m_coll_params, &m_planc); + m_builtin_ctx = (ucg_builtin_group_ctx_t *)UCG_GROUP_TO_COMPONENT_CTX(ucg_builtin_component, m_group); } ucg_plan_test::~ucg_plan_test() @@ -51,53 +49,47 @@ ucg_plan_test::~ucg_plan_test() m_group_params = NULL; } - if (m_planner_p != NULL) { - delete m_planner_p; - m_planner_p = NULL; - } - m_all_rank_infos.clear(); } - TEST(ucg_plan_test, ucg_plan_1_test) { ucg_plan_test example(4, 8, 0); + size_t msg_size = UCG_GROUP_MED_MSG_SIZE - 1024; ucg_plan_t *plan = NULL; - - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucs_status_t ret = ucg_group_select_planner(example.m_group, NULL, example.m_coll_params, - &planner, &planner_ctx); + ucs_status_t ret = ucg_builtin_component.create(&ucg_builtin_component, example.m_ucg_worker, + example.m_group, 23, 0, NULL, example.m_group_params); EXPECT_EQ(UCS_OK, ret); - ret = example.m_planner_p->plan(planner_ctx, example.m_coll_params, &plan); + ret = ucg_builtin_component.plan(&ucg_builtin_component, &example.m_coll_type, msg_size, + example.m_group, example.m_coll_params, &plan); EXPECT_EQ(UCS_OK, ret); + } TEST(ucg_plan_test, ucg_plan_2_test) { ucg_plan_test example(4, 8, 0); - + size_t msg_size = UCG_GROUP_MED_MSG_SIZE + 1024; ucg_plan_t *plan = NULL; - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucs_status_t ret = ucg_group_select_planner(example.m_group, NULL, example.m_coll_params, - &planner, &planner_ctx); + ucs_status_t ret = ucg_builtin_component.create(&ucg_builtin_component, example.m_ucg_worker, + example.m_group, 23, 0, NULL, example.m_group_params); EXPECT_EQ(UCS_OK, ret); - ret = example.m_planner_p->plan(planner_ctx, example.m_coll_params, &plan); + ret = ucg_builtin_component.plan(&ucg_builtin_component, &example.m_coll_type, msg_size, + example.m_group, example.m_coll_params, &plan); EXPECT_EQ(UCS_OK, ret); } TEST(ucg_plan_test, ucg_plan_3_test) { ucg_plan_test example(4, 8, 0); + size_t msg_size = UCG_GROUP_MED_MSG_SIZE - 1024; + ucg_plan_t *plan = NULL; - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucs_status_t ret = ucg_group_select_planner(example.m_group, NULL, example.m_coll_params, - &planner, &planner_ctx); + ucs_status_t ret = ucg_builtin_component.create(&ucg_builtin_component, example.m_ucg_worker, + example.m_group, 23, 0, NULL, example.m_group_params); EXPECT_EQ(UCS_OK, ret); - ret = example.m_planner_p->plan(planner_ctx, example.m_coll_params, &plan); + ret = ucg_builtin_component.plan(&ucg_builtin_component, &example.m_coll_type, msg_size, + example.m_group, example.m_coll_params, &plan); EXPECT_EQ(UCS_OK, ret); } /* @@ -106,7 +98,7 @@ TEST(ucg_plan_test, ucg_plan_4_test) { size_t msg_size = UCG_GROUP_MED_MSG_SIZE + 1024; ucg_plan_t *plan; - ucs_status_t ret = ucg_builtin_component.create(&ucg_builtin_component, example.m_ucp_worker, + ucs_status_t ret = ucg_builtin_component.create(&ucg_builtin_component, example.m_ucg_worker, example.m_group, 23, 0, NULL, example.m_group_params); EXPECT_EQ(UCS_OK, ret); ret = ucg_builtin_component.plan(&ucg_builtin_component, &example.m_coll_type, msg_size, @@ -115,29 +107,37 @@ TEST(ucg_plan_test, ucg_plan_4_test) { } */ TEST(ucg_plan_test, algorithm_selection) { + ucs_status_t ret; unsigned idx; for (idx = 0; idx < UCG_ALGORITHM_ALLREDUCE_LAST; idx++) { - ucg_builtin_allreduce_algo_switch((enum ucg_builtin_allreduce_algorithm) idx, &ucg_builtin_algo_config); + ret = ucg_builtin_allreduce_algo_switch((enum ucg_builtin_allreduce_algorithm) idx, &ucg_algo); + ASSERT_EQ(UCS_OK, ret); } for (idx = 0; idx < UCG_ALGORITHM_BARRIER_LAST; idx++) { - ucg_builtin_barrier_algo_switch((enum ucg_builtin_barrier_algorithm) idx, &ucg_builtin_algo_config); + ret = ucg_builtin_barrier_algo_switch((enum ucg_builtin_barrier_algorithm) idx, &ucg_algo); + ASSERT_EQ(UCS_OK, ret); } for (idx = 0; idx < UCG_ALGORITHM_BCAST_LAST; idx++) { - ucg_builtin_bcast_algo_switch((enum ucg_builtin_bcast_algorithm) idx, &ucg_builtin_algo_config); + ret = ucg_builtin_bcast_algo_switch((enum ucg_builtin_bcast_algorithm) idx, &ucg_algo); + ASSERT_EQ(UCS_OK, ret); } } TEST(ucg_plan_test, topo_level) { - ucg_builtin_algo_config.topo_level = UCG_GROUP_HIERARCHY_LEVEL_NODE; + ucs_status_t ret; + ucg_algo.topo_level = UCG_GROUP_HIERARCHY_LEVEL_NODE; enum ucg_group_member_distance domain_distance = UCG_GROUP_MEMBER_DISTANCE_SELF; - choose_distance_from_topo_aware_level(&domain_distance); - ucg_builtin_algo_config.topo_level = UCG_GROUP_HIERARCHY_LEVEL_SOCKET; - choose_distance_from_topo_aware_level(&domain_distance); - ucg_builtin_algo_config.topo_level = UCG_GROUP_HIERARCHY_LEVEL_L3CACHE; - choose_distance_from_topo_aware_level(&domain_distance); + ret = choose_distance_from_topo_aware_level(&domain_distance); + ASSERT_EQ(UCS_OK, ret); + ucg_algo.topo_level = UCG_GROUP_HIERARCHY_LEVEL_SOCKET; + ret = choose_distance_from_topo_aware_level(&domain_distance); + ASSERT_EQ(UCS_OK, ret); + ucg_algo.topo_level = UCG_GROUP_HIERARCHY_LEVEL_L3CACHE; + ret = choose_distance_from_topo_aware_level(&domain_distance); + ASSERT_EQ(UCS_OK, ret); } TEST(ucg_plan_test, check_continus_number) { @@ -163,6 +163,50 @@ TEST(ucg_plan_test, check_continus_number) { ASSERT_EQ(1u, discount); } +TEST(ucg_plan_test, choose_type) { + + enum ucg_collective_modifiers flags[] = \ + { UCG_GROUP_COLLECTIVE_MODIFIER_SINGLE_SOURCE, UCG_GROUP_COLLECTIVE_MODIFIER_SINGLE_DESTINATION, \ + UCG_GROUP_COLLECTIVE_MODIFIER_AGGREGATE, UCG_GROUP_COLLECTIVE_MODIFIER_AGGREGATE, UCG_GROUP_COLLECTIVE_MODIFIER_AGGREGATE, \ + UCG_GROUP_COLLECTIVE_MODIFIER_ALLGATHER, UCG_GROUP_COLLECTIVE_MODIFIER_ALLGATHER}; + + enum ucg_builtin_plan_topology_type expect_result[] = {UCG_PLAN_TREE_FANOUT, UCG_PLAN_TREE_FANIN, \ + UCG_PLAN_RECURSIVE, UCG_PLAN_RING, UCG_PLAN_TREE_FANIN_FANOUT, \ + UCG_PLAN_BRUCK, UCG_PLAN_RECURSIVE}; + enum ucg_builtin_plan_topology_type ret_type; + /* TODO */ + unsigned case_num = 7; + for (unsigned i = 0; i < case_num; i++) { + + switch (i) + { + case 2: + ucg_algo.recursive = 1; + ucg_algo.ring = 0; + ucg_algo.bruck = 0; + break; + case 3: + ucg_algo.recursive = 0; + ucg_algo.ring = 1; + ucg_algo.bruck = 0; + break; + case 5: + ucg_algo.recursive = 0; + ucg_algo.ring = 0; + ucg_algo.bruck = 1; + break; + default: + ucg_algo.recursive = 0; + ucg_algo.ring = 0; + ucg_algo.bruck = 0; + break; + } + + ret_type = ucg_builtin_choose_type(flags[i]); + ASSERT_EQ(expect_result[i], ret_type); + } +} + /* TODO: add verification to below functions */ /* TEST(ucg_plan_test, plan_decision_in_discontinuous_case) { @@ -180,7 +224,6 @@ TEST(ucg_plan_test, plan_decision_in_discontinuous_case) { } } */ - TEST(ucg_plan_test, plan_decision_fixed) { ucg_plan_test example(2, 2, 0); unsigned op_num = 3; @@ -198,9 +241,7 @@ TEST(ucg_plan_test, plan_decision_fixed) { for (unsigned i = 0; i < op_num; i++) { for (unsigned j = 0; j < size_num; j++) { for (unsigned k = 0; k < data_num; k++) { - plan_decision_fixed(msg_size[j], example.m_group_params, modifiers[i], - example.m_coll_params, large_data[k], 0, - &bcast_algo_decision, &allreduce_algo_decision, &barrier_algo_decision); + plan_decision_fixed(msg_size[j], example.m_group_params, modifiers[i], example.m_coll_params, large_data[k], 0, &bcast_algo_decision, &allreduce_algo_decision, &barrier_algo_decision); } } } @@ -208,31 +249,18 @@ TEST(ucg_plan_test, plan_decision_fixed) { TEST(ucg_plan_test, plan_chooose_ops) { ucg_plan_test example(2, 2, 0); - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucs_status_t ret = ucg_group_select_planner(example.m_group, NULL, example.m_coll_params, - &planner, &planner_ctx); - ASSERT_EQ(UCS_OK, ret); - ucg_builtin_planner_ctx_t *ctx = (ucg_builtin_planner_ctx_t *)planner_ctx; unsigned op_num = 3; enum ucg_collective_modifiers modifiers[op_num] = { (enum ucg_collective_modifiers ) (UCG_GROUP_COLLECTIVE_MODIFIER_BROADCAST | UCG_GROUP_COLLECTIVE_MODIFIER_SINGLE_SOURCE), \ (enum ucg_collective_modifiers) (UCG_GROUP_COLLECTIVE_MODIFIER_AGGREGATE | UCG_GROUP_COLLECTIVE_MODIFIER_BROADCAST | UCG_GROUP_COLLECTIVE_MODIFIER_BARRIER), \ (enum ucg_collective_modifiers) (UCG_GROUP_COLLECTIVE_MODIFIER_AGGREGATE | UCG_GROUP_COLLECTIVE_MODIFIER_BROADCAST) }; for (unsigned i = 0; i < op_num; i++) { - ucg_builtin_plan_choose_ops(ctx->config, modifiers[i]); + ucg_builtin_plan_choose_ops(example.m_planc, modifiers[i]); } } TEST(ucg_plan_test, test_algorithm_decision) { ucg_plan_test example(2, 2, 0); - - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucs_status_t ret = ucg_group_select_planner(example.m_group, NULL, example.m_coll_params, - &planner, &planner_ctx); - ASSERT_EQ(UCS_OK, ret); - ucg_builtin_planner_ctx_t *ctx = (ucg_builtin_planner_ctx_t *)planner_ctx; - ret = ucg_builtin_algorithm_decision(ctx, example.m_coll_params); + ucs_status_t ret = ucg_builtin_algorithm_decision(&(example.m_coll_type), 1024, example.m_group_params, example.m_coll_params, example.m_planc); ASSERT_EQ(UCS_OK, ret); } diff --git a/test/gtest/ucg/test_cb.cc b/test/gtest/ucg/test_cb.cc index ba477e79d2b..2213c257a44 100644 --- a/test/gtest/ucg/test_cb.cc +++ b/test/gtest/ucg/test_cb.cc @@ -11,77 +11,37 @@ using namespace std; class ucg_cb_test : public ucg_op_test { public: ucg_cb_test() { - ucg_builtin_num_procs = 2; + num_procs = 2; } ~ ucg_cb_test() = default; public: - void create_slot(ucg_builtin_comp_slot_t *&slot); - ucg_builtin_request_t* create_request(ucg_builtin_op_step_t *step, ucg_builtin_comp_slot_t *slot); - void destroy_request(ucg_builtin_request_t *&req); - void destroy_slot(ucg_builtin_comp_slot_t *&slot); + ucg_builtin_request_t* create_request(ucg_builtin_op_step_t *step); }; -void ucg_cb_test::create_slot(ucg_builtin_comp_slot_t *&slot) -{ - slot = new ucg_builtin_comp_slot_t(); +ucg_builtin_request_t* ucg_cb_test::create_request(ucg_builtin_op_step_t *step) { + ucg_builtin_comp_slot_t *slot = new ucg_builtin_comp_slot_t; slot->cb = NULL; slot->step_idx = 1; ucs_list_head_init(&slot->msg_head); -} -ucg_builtin_request_t* ucg_cb_test::create_request(ucg_builtin_op_step_t *step, ucg_builtin_comp_slot_t *slot) -{ ucg_builtin_request_t *req = &slot->req; req->step = step; - ucg_request_t *comp_req = new ucg_request_t(); + ucg_request_t *comp_req = new ucg_request_t; comp_req->flags = 0; comp_req->status = UCS_OK; req->comp_req = comp_req; - ucg_builtin_op_t *op = new ucg_builtin_op_t(); + ucg_builtin_op_t *op = new ucg_builtin_op_t; op->send_dt = NULL; op->recv_dt = NULL; op->final_cb = NULL; req->op = op; - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucg_group_h group = create_group(); - ucg_collective_params_t *params = create_allreduce_params(); - ucg_group_select_planner(group, NULL, params, &planner, &planner_ctx); - ucg_builtin_component.query(&planner); - ucg_plan_t *plan = NULL; - planner->plan(planner_ctx, params, &plan); - plan->planner = planner; - req->op->super.plan = plan; - group->planners_context = NULL; return req; } -void ucg_cb_test::destroy_request(ucg_builtin_request_t *&req) -{ - if (req != NULL) { - if (req->op != NULL) { - delete(req->op); - req->op = NULL; - } - if (req->comp_req != NULL) { - delete(req->comp_req); - req->comp_req = NULL; - } - } -} - -void ucg_cb_test::destroy_slot(ucg_builtin_comp_slot_t *&slot) -{ - if (slot != NULL) { - delete(slot); - slot = NULL; - } -} - -static void reduce_mock(void *mpi_op, void *src_buffer, void *dst_buffer, int dcount, void *mpi_datatype) +static void reduce_mock(void *mpi_op, char *src_buffer, char *dst_buffer, unsigned dcount, void *mpi_datatype) { // do nothing } @@ -112,11 +72,10 @@ static ucs_status_t coll_ucx_generic_datatype_unpack(void *state, size_t offset, return UCS_OK; } -TEST_F(ucg_cb_test, test_op_no_optimization) -{ - ucg_builtin_op_t *op = new ucg_builtin_op_t(); +TEST_F(ucg_cb_test, test_op_no_optimization) { + ucg_builtin_op_t *op = new ucg_builtin_op_t; ucs_status_t ret = ucg_builtin_no_optimization(op); - delete op; + ASSERT_EQ(UCS_OK, ret); } @@ -124,7 +83,7 @@ TEST_F(ucg_cb_test, test_op_cb_init) { ucg_group_h group = create_group(); ucg_collective_params_t *params = create_allreduce_params(); ucg_plan_t *plan = create_plan(1, params, group); - ucp_dt_generic_t *dt_gen = new ucp_dt_generic_t(); + ucp_dt_generic_t *dt_gen = new ucp_dt_generic_t; ucg_op_t *op = new ucg_op_t(); ucs_status_t ret = ucg_builtin_op_create(plan, params, &op); @@ -139,7 +98,7 @@ TEST_F(ucg_cb_test, test_op_cb_init) { step->non_contig.unpack_state = (void *)step->recv_buffer; int *send_buf = (int *)params->send.buf; int *recv_buf = (int *)params->recv.buf; - ucg_builtin_request_t *req = new ucg_builtin_request_t(); + ucg_builtin_request_t *req = new ucg_builtin_request_t; req->op = (ucg_builtin_op_t *)op; req->step = step; dt_gen->context = (void *)step->recv_buffer; @@ -199,13 +158,12 @@ TEST_F(ucg_cb_test, test_op_cb_init) { ucg_builtin_init_reduce_and_unpack((ucg_builtin_op_t *)op); ASSERT_EQ(send_buf[0], recv_buf[0]); + params->send.buf = MPI_IN_PLACE; ucg_builtin_init_reduce((ucg_builtin_op_t *)op); ASSERT_EQ(recv_buf[0], recv_buf[0]); delete req; delete dt_gen; - destroy_collective_params(params); - destroy_group(group); } TEST_F(ucg_cb_test, test_op_cb_final) { @@ -214,8 +172,11 @@ TEST_F(ucg_cb_test, test_op_cb_final) { ucg_plan_t *plan = create_plan(1, params, group); ucg_op_t *op = new ucg_op_t(); + ucs_status_t ret = ucg_builtin_op_create(plan, params, &op); ASSERT_EQ(UCS_OK, ret); + + op->params = *params; op->plan = plan; plan->my_index = 1; ucg_builtin_op_step_t *step = &((ucg_builtin_op_t *)op)->steps[0]; @@ -281,7 +242,6 @@ TEST_F(ucg_cb_test, test_op_cb_final) { delete req; delete dt_gen; - destroy_group(group); } TEST_F(ucg_cb_test, test_send_cb) { @@ -310,7 +270,6 @@ TEST_F(ucg_cb_test, test_send_cb) { ucg_builtin_send_alltoall(req); ASSERT_EQ(recv_buf[1], send_buf[0]); - destroy_collective_params(params); } TEST_F(ucg_cb_test, test_recv_cb_recv_one) { @@ -328,9 +287,7 @@ TEST_F(ucg_cb_test, test_recv_cb_recv_one) { params, ¤t_data_buffer, step); ASSERT_EQ(UCS_OK, ret); - ucg_builtin_comp_slot_t *slot = NULL; - create_slot(slot); - ucg_builtin_request_t *req = create_request(step, slot); + ucg_builtin_request_t *req = create_request(step); req->step->non_contig.unpack_state = (void *)step->recv_buffer; req->op->recv_dt = dt_gen; req->op->recv_dt->ops.unpack = coll_ucx_generic_datatype_unpack; @@ -373,9 +330,7 @@ TEST_F(ucg_cb_test, test_recv_cb_recv_one) { for (int i = 0; i < count; i++) { ASSERT_EQ(i, recv_buf[i]); } - destroy_request(req); - destroy_slot(slot); - destroy_collective_params(params); + delete dt_gen; } @@ -394,9 +349,7 @@ TEST_F(ucg_cb_test, test_recv_cb_recv_many) { params, ¤t_data_buffer, step); ASSERT_EQ(UCS_OK, ret); - ucg_builtin_comp_slot_t *slot = NULL; - create_slot(slot); - ucg_builtin_request_t *req = create_request(step, slot); + ucg_builtin_request_t *req = create_request(step); req->step->non_contig.unpack_state = (void *)step->recv_buffer; req->op->recv_dt = dt_gen; req->op->recv_dt->ops.unpack = coll_ucx_generic_datatype_unpack; @@ -466,9 +419,6 @@ TEST_F(ucg_cb_test, test_recv_cb_recv_many) { ret_int = ucg_builtin_comp_recv_noncontig_many_then_send_pipe_cb(req, offset, (void *)data, length); ASSERT_EQ(1, ret_int); - destroy_request(req); - destroy_slot(slot); - destroy_collective_params(params); delete dt_gen; } @@ -486,9 +436,7 @@ TEST_F(ucg_cb_test, test_recv_cb_reduce_one) { params, ¤t_data_buffer, step); ASSERT_EQ(UCS_OK, ret); - ucg_builtin_comp_slot_t *slot = NULL; - create_slot(slot); - ucg_builtin_request_t *req = create_request(step, slot); + ucg_builtin_request_t *req = create_request(step); uint64_t offset = 0; int count = 2; @@ -509,9 +457,6 @@ TEST_F(ucg_cb_test, test_recv_cb_reduce_one) { req->comp_req->flags = 0; ret_int = ucg_builtin_comp_reduce_one_then_send_cb(req, offset, (void *)data, length); ASSERT_EQ(1, ret_int); - destroy_request(req); - destroy_slot(slot); - destroy_collective_params(params); } TEST_F(ucg_cb_test, test_recv_cb_reduce_many) { @@ -528,9 +473,7 @@ TEST_F(ucg_cb_test, test_recv_cb_reduce_many) { params, ¤t_data_buffer, step); ASSERT_EQ(UCS_OK, ret); - ucg_builtin_comp_slot_t *slot = NULL; - create_slot(slot); - ucg_builtin_request_t *req = create_request(step, slot); + ucg_builtin_request_t *req = create_request(step); uint64_t offset = 0; int count = 2; @@ -566,9 +509,6 @@ TEST_F(ucg_cb_test, test_recv_cb_reduce_many) { step->iter_offset = UCG_BUILTIN_OFFSET_PIPELINE_PENDING; ret_int = ucg_builtin_comp_reduce_many_then_send_pipe_cb(req, offset, (void *)data, length); ASSERT_EQ(1, ret_int); - destroy_request(req); - destroy_slot(slot); - destroy_collective_params(params); } TEST_F(ucg_cb_test, test_recv_cb_reduce_full) { @@ -585,9 +525,7 @@ TEST_F(ucg_cb_test, test_recv_cb_reduce_full) { params, ¤t_data_buffer, step); ASSERT_EQ(UCS_OK, ret); - ucg_builtin_comp_slot_t *slot = NULL; - create_slot(slot); - ucg_builtin_request_t *req = create_request(step, slot); + ucg_builtin_request_t *req = create_request(step); uint64_t offset = 0; int count = 2; @@ -617,9 +555,6 @@ TEST_F(ucg_cb_test, test_recv_cb_reduce_full) { for (int i = 0; i < count; i++) { ASSERT_EQ(i, cache[i]); } - destroy_request(req); - destroy_slot(slot); - destroy_collective_params(params); } TEST_F(ucg_cb_test, test_recv_cb_wait) { @@ -636,9 +571,7 @@ TEST_F(ucg_cb_test, test_recv_cb_wait) { params, ¤t_data_buffer, step); ASSERT_EQ(UCS_OK, ret); - ucg_builtin_comp_slot_t *slot = NULL; - create_slot(slot); - ucg_builtin_request_t *req = create_request(step, slot); + ucg_builtin_request_t *req = create_request(step); uint64_t offset = 0; int count = 2; @@ -659,9 +592,6 @@ TEST_F(ucg_cb_test, test_recv_cb_wait) { ret_int = ucg_builtin_comp_wait_many_then_send_cb(req, offset, (void *)data, length); ASSERT_EQ(1, ret_int); - destroy_request(req); - destroy_slot(slot); - destroy_collective_params(params); } TEST_F(ucg_cb_test, test_recv_cb_last_barrier) { @@ -678,9 +608,7 @@ TEST_F(ucg_cb_test, test_recv_cb_last_barrier) { params, ¤t_data_buffer, step); ASSERT_EQ(UCS_OK, ret); - ucg_builtin_comp_slot_t *slot = NULL; - create_slot(slot); - ucg_builtin_request_t *req = create_request(step, slot); + ucg_builtin_request_t *req = create_request(step); ucg_group_h group = create_group(); ucg_plan_t *plan = create_plan(1, params, group); @@ -702,10 +630,6 @@ TEST_F(ucg_cb_test, test_recv_cb_last_barrier) { ASSERT_EQ(0, ret_int); ret_int = ucg_builtin_comp_last_barrier_step_many_cb(req, offset, (void *)data, length); ASSERT_EQ(1, ret_int); - destroy_request(req); - destroy_slot(slot); - destroy_group(group); - destroy_collective_params(params); } TEST_F(ucg_cb_test, test_zcopy_step_check_cb) { @@ -722,9 +646,7 @@ TEST_F(ucg_cb_test, test_zcopy_step_check_cb) { params, ¤t_data_buffer, step); ASSERT_EQ(UCS_OK, ret); - ucg_builtin_comp_slot_t *slot = NULL; - create_slot(slot); - ucg_builtin_request_t *req = create_request(step, slot); + ucg_builtin_request_t *req = create_request(step); ucg_builtin_zcomp_t *zcomp = new ucg_builtin_zcomp_t; zcomp->req = req; uct_completion_t *self = &zcomp->comp; @@ -733,24 +655,12 @@ TEST_F(ucg_cb_test, test_zcopy_step_check_cb) { step->zcopy.num_store = 0; ucg_builtin_step_am_zcopy_comp_step_check_cb(self, UCS_OK); - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucg_group_h group = create_group(); - ucg_group_select_planner(group, NULL, params, &planner, &planner_ctx); - req->pending = 2; step->zcopy.num_store = 1; - ucg_plan_t *plan = create_plan(1, params, group); - plan->planner = planner; + ucg_plan_t *plan = new ucg_plan_t; + plan->planner = &ucg_builtin_component; req->op->super.plan = plan; - ucg_builtin_step_am_zcopy_comp_step_check_cb(self, UCS_OK); - destroy_request(req); - destroy_slot(slot); - destroy_collective_params(params); - group->planners_context = NULL; - m_ucp_worker = NULL; - m_ucp_context = NULL; } TEST_F(ucg_cb_test, test_zcopy_prep) { @@ -772,7 +682,6 @@ TEST_F(ucg_cb_test, test_zcopy_prep) { ret = ucg_builtin_step_zcopy_prep(step); ASSERT_EQ(UCS_OK, ret); - destroy_collective_params(params); } TEST_F(ucg_cb_test, test_bcopy_to_zcopy) { @@ -793,14 +702,11 @@ TEST_F(ucg_cb_test, test_bcopy_to_zcopy) { step->uct_md = md; step->recv_cb = ucg_builtin_comp_reduce_one_cb; - ucg_builtin_op_t *op = (ucg_builtin_op_t *)malloc(sizeof(ucg_builtin_op_t) + sizeof(ucg_builtin_op_step_t)); + ucg_builtin_op_t *op = new ucg_builtin_op_t + sizeof(ucg_builtin_op_step_t); op->steps[0] = *step; ret = ucg_builtin_optimize_bcopy_to_zcopy(op); ASSERT_EQ(UCS_OK, ret); - destroy_collective_params(params); - delete step; - free(op); } /** @@ -936,14 +842,12 @@ TEST_F(ucg_cb_test, test_op_consider_optimization) { ucg_collective_params_t *params = create_bcast_params(); ucg_plan_t *plan = create_plan(1, params, group); - ucg_op_t *op = NULL; + ucg_op_t *op = new ucg_op_t(); ucs_status_t ret = ucg_builtin_op_create(plan, params, &op); ASSERT_EQ(UCS_OK, ret); ret = ucg_builtin_op_consider_optimization((ucg_builtin_op_t*)op, - ((ucg_builtin_plan_t *)plan)->context->config); + (ucg_builtin_config_t*)plan->planner->plan_config); ASSERT_EQ(UCS_OK, ret); - destroy_collective_params(params); - destroy_group(group); } diff --git a/test/gtest/ucg/test_coll_algorithm.cc b/test/gtest/ucg/test_coll_algorithm.cc index 6ac0902dcc6..73cd37046bc 100644 --- a/test/gtest/ucg/test_coll_algorithm.cc +++ b/test/gtest/ucg/test_coll_algorithm.cc @@ -8,6 +8,7 @@ extern "C" { #include #include +#include } #include "ucg_test.h" @@ -26,7 +27,7 @@ TEST(ucg_plan_test, test_ring) { for (unsigned i = 0; i < sizeof(data) / sizeof(data[0]); i++) { obj = new ucg_plan_test(data[i].node_cnt, data[i].ppn, data[i].myrank); ret = ucg_builtin_ring_create(obj->m_builtin_ctx, UCG_PLAN_RING, - (ucg_builtin_config_t *)obj->m_builtin_ctx->config, + (ucg_builtin_config_t *)obj->m_planc->plan_config, obj->m_group_params, &obj->m_coll_type, &plan); delete obj; @@ -46,7 +47,7 @@ TEST(ucg_plan_test, test_recursive) { for (unsigned i = 0; i < sizeof(data) / sizeof(data[0]); i++) { obj = new ucg_plan_test(data[i].node_cnt, data[i].ppn, data[i].myrank); ret = ucg_builtin_recursive_create(obj->m_builtin_ctx, UCG_PLAN_RECURSIVE, - (ucg_builtin_config_t *)obj->m_builtin_ctx->config, + (ucg_builtin_config_t *)obj->m_planc->plan_config, obj->m_group_params, &obj->m_coll_type, &plan); delete obj; @@ -58,81 +59,81 @@ static void ucg_algo_set(int option) { switch (option) { case 0: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 1; - ucg_builtin_algo_config.kmtree = 1; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 1; + ucg_algo.kmtree = 1; return; case 1: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 0; - ucg_builtin_algo_config.kmtree = 1; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 0; + ucg_algo.kmtree = 1; return; case 2: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 0; - ucg_builtin_algo_config.kmtree = 0; - ucg_builtin_algo_config.topo_level = UCG_GROUP_HIERARCHY_LEVEL_NODE; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 0; + ucg_algo.kmtree = 0; + ucg_algo.topo_level = UCG_GROUP_HIERARCHY_LEVEL_NODE; return; case 3: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 0; - ucg_builtin_algo_config.kmtree = 0; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 0; + ucg_algo.kmtree = 0; return; case 4: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 0; - ucg_builtin_algo_config.kmtree = 0; - ucg_builtin_algo_config.topo_level = UCG_GROUP_HIERARCHY_LEVEL_SOCKET; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 0; + ucg_algo.kmtree = 0; + ucg_algo.topo_level = UCG_GROUP_HIERARCHY_LEVEL_SOCKET; return; case 5: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 1; - ucg_builtin_algo_config.topo_level = UCG_GROUP_HIERARCHY_LEVEL_SOCKET; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 1; + ucg_algo.topo_level = UCG_GROUP_HIERARCHY_LEVEL_SOCKET; return; case 6: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 1; - ucg_builtin_algo_config.kmtree = 1; - ucg_builtin_algo_config.topo_level = UCG_GROUP_HIERARCHY_LEVEL_SOCKET; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 1; + ucg_algo.kmtree = 1; + ucg_algo.topo_level = UCG_GROUP_HIERARCHY_LEVEL_SOCKET; return; case 7: - ucg_builtin_algo_config.topo = 1; + ucg_algo.topo = 1; return; case 8: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 1; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 1; return; case 9: - ucg_builtin_algo_config.topo = 1; - ucg_builtin_algo_config.bmtree = 1; - ucg_builtin_algo_config.recursive = 0; - ucg_builtin_algo_config.kmtree_intra = 1; - ucg_builtin_algo_config.kmtree = 1; + ucg_algo.topo = 1; + ucg_algo.bmtree = 1; + ucg_algo.recursive = 0; + ucg_algo.kmtree_intra = 1; + ucg_algo.kmtree = 1; return; default: @@ -168,7 +169,7 @@ TEST(ucg_plan_test, test_binomial_tree) { obj = new ucg_plan_test(fanout[i].data.node_cnt, fanout[i].data.ppn, fanout[i].data.myrank); ucg_algo_set(fanout[i].algo_id); ret = ucg_builtin_binomial_tree_create(obj->m_builtin_ctx, UCG_PLAN_TREE_FANOUT, - (ucg_builtin_config_t *)obj->m_builtin_ctx->config, + (ucg_builtin_config_t *)obj->m_planc->plan_config, obj->m_group_params, &obj->m_coll_type, &plan); delete obj; @@ -179,7 +180,7 @@ TEST(ucg_plan_test, test_binomial_tree) { obj = new ucg_plan_test(fanin_out[i].data.node_cnt, fanin_out[i].data.ppn, fanin_out[i].data.myrank); ucg_algo_set(fanin_out[i].algo_id); ret = ucg_builtin_binomial_tree_create(obj->m_builtin_ctx, UCG_PLAN_TREE_FANIN_FANOUT, - (ucg_builtin_config_t *)obj->m_builtin_ctx->config, + (ucg_builtin_config_t *)obj->m_planc->plan_config, obj->m_group_params, &obj->m_coll_type, &plan); delete obj; diff --git a/test/gtest/ucg/test_collective.cc b/test/gtest/ucg/test_collective.cc index 2438e785922..39255f3de13 100644 --- a/test/gtest/ucg/test_collective.cc +++ b/test/gtest/ucg/test_collective.cc @@ -26,10 +26,10 @@ ucg_collective_test::ucg_collective_test() { m_all_rank_infos.clear(); m_resource_factory->create_balanced_rank_info(m_all_rank_infos, 2, 2); - m_group_params = m_resource_factory->create_group_params(m_all_rank_infos[0], m_all_rank_infos, m_ucp_worker); - m_group2_params = m_resource_factory->create_group_params(m_all_rank_infos[1], m_all_rank_infos, m_ucp_worker); - m_resource_factory->create_group(m_group_params, m_ucg_context, &m_group); - m_resource_factory->create_group(m_group2_params, m_ucg_context, &m_group2); + m_group_params = m_resource_factory->create_group_params(m_all_rank_infos[0], m_all_rank_infos); + m_group2_params = m_resource_factory->create_group_params(m_all_rank_infos[1], m_all_rank_infos); + m_group = m_resource_factory->create_group(m_group_params, m_ucg_worker); + m_group2 = m_resource_factory->create_group(m_group2_params, m_ucg_worker); m_coll_params = m_resource_factory->create_collective_params( UCG_GROUP_COLLECTIVE_MODIFIER_SINGLE_SOURCE, 0, NULL, 1, NULL, 4, NULL, NULL); @@ -42,6 +42,9 @@ ucg_collective_test::~ucg_collective_test() m_coll_params = NULL; } + ucg_group_destroy(m_group2); + ucg_group_destroy(m_group); + if (m_group2_params != NULL) { delete m_group2_params; m_group2_params = NULL; @@ -62,8 +65,6 @@ TEST_F(ucg_collective_test, test_collective_create) { ucs_status_t ret = ucg_collective_create(m_group, m_coll_params, &coll); ASSERT_EQ(UCS_OK, ret); - - m_group->planners_context = NULL; } TEST_F(ucg_collective_test, test_collective_start_nb) { @@ -75,8 +76,6 @@ TEST_F(ucg_collective_test, test_collective_start_nb) { ucs_status_ptr_t retP = ucg_collective_start_nb(coll); ASSERT_TRUE(retP != NULL); - - m_group2->planners_context = NULL; } TEST_F(ucg_collective_test, test_collective_start_nbr) { @@ -89,7 +88,6 @@ TEST_F(ucg_collective_test, test_collective_start_nbr) { ucg_collective_start_nbr(coll, req); //ASSERT_EQ(UCS_OK, retS); - m_group2->planners_context = NULL; } TEST_F(ucg_collective_test, test_collective_destroy) { @@ -100,6 +98,4 @@ TEST_F(ucg_collective_test, test_collective_destroy) { //TODO ASSERT_TRUE(true); - - m_group->planners_context = NULL; } diff --git a/test/gtest/ucg/test_group.cc b/test/gtest/ucg/test_group.cc index 5604697b199..551194d6106 100644 --- a/test/gtest/ucg/test_group.cc +++ b/test/gtest/ucg/test_group.cc @@ -11,8 +11,8 @@ class ucg_group_test : public ucg_test { public: ucg_group_test() { m_all_rank_infos.clear(); - m_resource_factory->create_balanced_rank_info(m_all_rank_infos, 2, 2, m_ucp_worker); - m_params = m_resource_factory->create_group_params(m_all_rank_infos[0], m_all_rank_infos, m_ucp_worker); + m_resource_factory->create_balanced_rank_info(m_all_rank_infos, 2, 2); + m_params = m_resource_factory->create_group_params(m_all_rank_infos[0], m_all_rank_infos); } ~ucg_group_test() { @@ -30,7 +30,7 @@ class ucg_group_test : public ucg_test { TEST_F(ucg_group_test, test_group_create) { ucg_group_h group; - ucs_status_t ret = ucg_group_create(m_ucg_context, m_params, &group); + ucs_status_t ret = ucg_group_create(m_ucg_worker, m_params, &group); ucg_group_destroy(group); ASSERT_EQ(UCS_OK, ret); @@ -38,7 +38,7 @@ TEST_F(ucg_group_test, test_group_create) { TEST_F(ucg_group_test, test_group_destroy) { ucg_group_h group; - ucs_status_t ret = ucg_group_create(m_ucg_context, m_params, &group); + ucs_status_t ret = ucg_group_create(m_ucg_worker, m_params, &group); EXPECT_EQ(UCS_OK, ret); ucg_group_destroy(group); @@ -48,7 +48,7 @@ TEST_F(ucg_group_test, test_group_destroy) { TEST_F(ucg_group_test, test_group_progress) { ucg_group_h group; - ucs_status_t retS = ucg_group_create(m_ucg_context, m_params, &group); + ucs_status_t retS = ucg_group_create(m_ucg_worker, m_params, &group); EXPECT_EQ(UCS_OK, retS); unsigned retU = ucg_group_progress(group); diff --git a/test/gtest/ucg/test_op.cc b/test/gtest/ucg/test_op.cc index 05f78a6217b..f61d31e9c1e 100644 --- a/test/gtest/ucg/test_op.cc +++ b/test/gtest/ucg/test_op.cc @@ -9,7 +9,7 @@ using namespace std; ucg_op_test::ucg_op_test() { - ucg_builtin_num_procs = 4; + num_procs = 4; }; ucg_op_test::~ucg_op_test() @@ -62,6 +62,7 @@ void ucg_op_test::destroy_phase(ucg_builtin_plan_phase_t *phase) delete phase->md_attr; phase->md_attr = NULL; } + delete phase; } } @@ -71,18 +72,17 @@ ucg_plan_t *ucg_op_test::create_plan(unsigned phs_cnt, ucg_collective_params_t * ucg_builtin_plan_t *builtin_plan = (ucg_builtin_plan_t *)malloc(sizeof(ucg_builtin_plan_t) + phs_cnt * sizeof(ucg_builtin_plan_phase_t)); ucg_plan_t *plan = &builtin_plan->super; - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; + ucg_plan_component_t *planc = NULL; + plan->group_id = 1; plan->my_index = 0; plan->group = group; - ucg_group_select_planner(group, NULL, params, &planner, &planner_ctx); - plan->planner = planner; + ucg_plan_select(group, NULL, params, &planc); + plan->planner = planc; builtin_plan->am_id = 1; builtin_plan->resend = NULL; builtin_plan->slots = NULL; builtin_plan->phs_cnt = phs_cnt; - builtin_plan->context = (ucg_builtin_planner_ctx_t *)planner_ctx; builtin_plan->convert_f = mca_coll_ucg_datatype_convert_for_ut; ucs_mpool_ops_t ops = { @@ -122,20 +122,9 @@ ucg_group_h ucg_op_test::create_group() vector all_rank_infos; all_rank_infos.push_back(my_rank_info); all_rank_infos.push_back(other_rank_info); - ucg_group_params_t *group_params = m_resource_factory->create_group_params(my_rank_info, - all_rank_infos, - m_ucp_worker); - ucg_group_h ucg_group = NULL; - m_resource_factory->create_group(group_params, m_ucg_context, &ucg_group); - return ucg_group; -} + ucg_group_params_t *group_params = m_resource_factory->create_group_params(my_rank_info, all_rank_infos); -void ucg_op_test::destroy_group(ucg_group_h &group) -{ - if (group != NULL) { - ucg_group_destroy(group); - group = NULL; - } + return m_resource_factory->create_group(group_params, m_ucg_worker); } ucs_status_t mem_reg_mock(uct_md_h md, void *address, size_t length, unsigned flags, uct_mem_h *memh_p) @@ -162,13 +151,13 @@ TEST_F(ucg_op_test, test_op_create_phase_1) { ucg_group_h group = create_group(); ucg_collective_params_t *params = create_bcast_params(); ucg_plan_t *plan = create_plan(1, params, group); + ucg_op_t *op = new ucg_op_t(); ucs_status_t ret = ucg_builtin_op_create(plan, params, &op); ASSERT_EQ(UCS_OK, ret); - destroy_collective_params(params); - destroy_group(group); + ucg_builtin_component.destroy(group); } TEST_F(ucg_op_test, test_op_create_phase_2) { @@ -181,8 +170,7 @@ TEST_F(ucg_op_test, test_op_create_phase_2) { ucs_status_t ret = ucg_builtin_op_create(plan, params, &op); ASSERT_EQ(UCS_OK, ret); - destroy_collective_params(params); - destroy_group(group); + ucg_builtin_component.destroy(group); } /** @@ -206,8 +194,7 @@ TEST_F(ucg_op_test, test_op_discard) { step->flags |= UCG_BUILTIN_OP_STEP_FLAG_PIPELINED; ucg_builtin_op_discard(op); - destroy_collective_params(params); - destroy_group(group); + ucg_builtin_component.destroy(group); } /** @@ -237,8 +224,7 @@ TEST_F(ucg_op_test, test_op_trigger) { ret = ucg_builtin_op_trigger(op, 0, &request); ASSERT_EQ(UCS_INPROGRESS, ret); - destroy_collective_params(params); - group->planners_context = NULL; - m_ucp_worker = NULL; - m_ucp_context = NULL; + ucg_builtin_component.destroy(group); + m_ucg_worker = NULL; + m_ucg_context = NULL; } diff --git a/test/gtest/ucg/test_op.h b/test/gtest/ucg/test_op.h index bef29090a5c..eba921a1b3e 100644 --- a/test/gtest/ucg/test_op.h +++ b/test/gtest/ucg/test_op.h @@ -25,8 +25,6 @@ class ucg_op_test : public ucg_test { ucg_group_h create_group(); - void destroy_group(ucg_group_h &group); - ucg_plan_t *create_plan(unsigned phs_cnt, ucg_collective_params_t *params, ucg_group_h group); ucg_builtin_plan_t *create_method_plan(ucg_builtin_plan_method_type method); diff --git a/test/gtest/ucg/test_plan.cc b/test/gtest/ucg/test_plan.cc index 6fe769fc95f..743fd5a0418 100644 --- a/test/gtest/ucg/test_plan.cc +++ b/test/gtest/ucg/test_plan.cc @@ -8,9 +8,30 @@ using namespace std; +TEST_F(ucg_test, select_plan_component) { + vector all_rank_infos; + + m_resource_factory->create_balanced_rank_info(all_rank_infos, 4, 8); + ucg_group_params_t *group_params = m_resource_factory->create_group_params(all_rank_infos[0], all_rank_infos); + ucg_group_h group = m_resource_factory->create_group(group_params, m_ucg_worker); + ucg_collective_params_t *params = m_resource_factory->create_collective_params( + UCG_GROUP_COLLECTIVE_MODIFIER_SINGLE_SOURCE, + 0, NULL, 1, NULL, 4, NULL, NULL); + ucg_plan_component_t *planc = NULL; + ucs_status_t ret = ucg_plan_select(group, NULL, params, &planc); + + ASSERT_EQ(UCS_OK, ret); + ASSERT_TRUE(planc != NULL); + + delete params; + ucg_group_destroy(group); + delete group_params; + all_rank_infos.clear(); +} + TEST_F(ucg_test, create_plan) { // vector all_rank_infos = m_resource_factory->create_balanced_rank_info(4,8); - // ucg_group_h group = m_resource_factory->create_group(all_rank_infos[0],all_rank_infos,m_ucp_worker); + // ucg_group_h group = m_resource_factory->create_group(all_rank_infos[0],all_rank_infos,m_ucg_worker); // ucg_collective_params_t *params = create_allreduce_params(); // ucg_collective_type_t coll_type = create_allreduce_coll_type(); // size_t msg_size = 32; @@ -26,12 +47,15 @@ TEST_F(ucg_test, create_plan_component) { vector all_rank_infos; m_resource_factory->create_balanced_rank_info(all_rank_infos, 4, 8); - ucg_group_params_t *group_params = m_resource_factory->create_group_params(all_rank_infos[0], - all_rank_infos, - m_ucp_worker); - ucg_group_h group = NULL; - ucs_status_t ret = m_resource_factory->create_group(group_params, m_ucg_context, &group); + ucg_group_params_t *group_params = m_resource_factory->create_group_params(all_rank_infos[0], all_rank_infos); + ucg_group_h group = m_resource_factory->create_group(group_params, m_ucg_worker); + unsigned base_am_id = 23; + ucg_group_id_t group_id = 0; + + ucs_status_t ret = ucg_builtin_component.create(&ucg_builtin_component, m_ucg_worker, group, + base_am_id, group_id, NULL, group_params); ASSERT_EQ(UCS_OK, ret); + ucg_group_destroy(group); delete group_params; all_rank_infos.clear(); @@ -41,12 +65,9 @@ TEST_F(ucg_test, destroy_group) { vector all_rank_infos; m_resource_factory->create_balanced_rank_info(all_rank_infos, 4, 8); - ucg_group_params_t *group_params = m_resource_factory->create_group_params(all_rank_infos[0], - all_rank_infos, - m_ucp_worker); - ucg_group_h group = NULL; - ucs_status_t ret = m_resource_factory->create_group(group_params, m_ucg_context, &group); - ASSERT_EQ(UCS_OK, ret); + ucg_group_params_t *group_params = m_resource_factory->create_group_params(all_rank_infos[0], all_rank_infos); + ucg_group_h group = m_resource_factory->create_group(group_params, m_ucg_worker); + ucg_builtin_component.destroy(group); ASSERT_TRUE(true); ucg_group_destroy(group); @@ -58,38 +79,24 @@ TEST_F(ucg_test, progress_group) { vector all_rank_infos; m_resource_factory->create_balanced_rank_info(all_rank_infos, 4, 8); - ucg_group_params_t *group_params = m_resource_factory->create_group_params(all_rank_infos[0], - all_rank_infos, - m_ucp_worker); - ucg_group_h ucg_group = NULL; - ucs_status_t ret = m_resource_factory->create_group(group_params, m_ucg_context, &ucg_group); - ASSERT_EQ(UCS_OK, ret); - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucg_collective_params_t * m_coll_params = m_resource_factory->create_collective_params( - UCG_GROUP_COLLECTIVE_MODIFIER_SINGLE_SOURCE, - 0, NULL, 1, NULL, 4, NULL, NULL); - ret = ucg_group_select_planner(ucg_group, NULL, m_coll_params, &planner, &planner_ctx); - ASSERT_EQ(UCS_OK, ret); - - ucg_planner_h planner_p; + ucg_group_params_t *group_params = m_resource_factory->create_group_params(all_rank_infos[0], all_rank_infos); + ucg_group_h group = m_resource_factory->create_group(group_params, m_ucg_worker); - ret = ucg_builtin_component.query(&planner_p); - ASSERT_EQ(UCS_OK, ret); - unsigned res = planner_p->progress(planner_ctx); + unsigned ret = ucg_builtin_component.progress(group); //TODO how to judge progress result? - cout << "ucg_builtin_component.progress return: " << res << endl; + cout << "ucg_builtin_component.progress return: " << ret << endl; - ucg_group_destroy(ucg_group); + ucg_group_destroy(group); delete group_params; all_rank_infos.clear(); } TEST_F(ucg_test, query_plan) { - ucg_planner_h planner_p; + ucg_plan_desc_t *planners; + unsigned num_plans; + ucs_status_t ret = ucg_builtin_component.query(0, &planners, &num_plans); - ucs_status_t ret = ucg_builtin_component.query(&planner_p); ASSERT_EQ(UCS_OK, ret); - ASSERT_STREQ("builtin", planner_p->name); - free(planner_p); + ASSERT_EQ((unsigned) 1, num_plans); + ASSERT_STREQ("builtin", planners[0].plan_name); } diff --git a/test/gtest/ucg/test_step.cc b/test/gtest/ucg/test_step.cc index f28aa0db338..ca23ee060cc 100644 --- a/test/gtest/ucg/test_step.cc +++ b/test/gtest/ucg/test_step.cc @@ -6,11 +6,11 @@ #include "test_op.h" using namespace std; -static void release_desc(void *t){} + class ucg_step_test : public ucg_op_test { public: ucg_step_test() { - ucg_builtin_num_procs = 4; + num_procs = 4; //ucs_global_opts.log_level = UCS_LOG_LEVEL_DEBUG; } @@ -22,7 +22,7 @@ class ucg_step_test : public ucg_op_test { }; ucg_builtin_comp_slot_t *ucg_step_test::create_slot(ucg_builtin_op_step_t *step) { - ucg_builtin_comp_slot_t *slot = new ucg_builtin_comp_slot_t(); + ucg_builtin_comp_slot_t *slot = new ucg_builtin_comp_slot_t; slot->cb = NULL; slot->step_idx = 0; slot->coll_id = 0; @@ -40,16 +40,10 @@ ucg_builtin_comp_slot_t *ucg_step_test::create_slot(ucg_builtin_op_step_t *step) op->final_cb = NULL; req->op = op; - ucg_planner_h planner = NULL; - ucg_planner_ctx_h planner_ctx; - ucg_group_h group = create_group(); - ucg_collective_params_t *params = create_allreduce_params(); - ucg_group_select_planner(group, NULL, params, &planner, &planner_ctx); - ucg_builtin_component.query(&planner); - ucg_plan_t *plan = NULL; - planner->plan(planner_ctx, params, &plan); - plan->planner = planner; + ucg_plan_t *plan = new ucg_plan_t; + plan->planner = &ucg_builtin_component; req->op->super.plan = plan; + return slot; } @@ -110,9 +104,7 @@ TEST_F(ucg_step_test, test_step_create_method) { } else { ASSERT_EQ(UCS_OK, ret); } - destroy_collective_params(params); } - } TEST_F(ucg_step_test, test_step_create_short) { @@ -252,6 +244,7 @@ TEST_F(ucg_step_test, test_msg_process) { ASSERT_EQ(UCS_OK, ret); ucg_builtin_comp_slot_t *slot = create_slot(step); + ret = ucg_builtin_msg_process(slot, &slot->req); ASSERT_EQ(UCS_INPROGRESS, ret); @@ -262,14 +255,12 @@ TEST_F(ucg_step_test, test_msg_process) { } size_t length = sizeof(int) * count; int *recv = (int *) step->recv_buffer; - slot->mp = &m_ucp_worker->am_mp; - + slot->mp = &m_ucg_worker->am_mp; ucg_builtin_comp_desc_t *desc = (ucg_builtin_comp_desc_t *) ucs_mpool_get_inline(slot->mp); memcpy(&desc->data[0], (void *) data, length); desc->super.flags = 0; desc->super.length = length; - desc->release_desc = release_desc; ucs_list_add_tail(&slot->msg_head, &desc->super.tag_list[0]); ret = ucg_builtin_msg_process(slot, &slot->req); @@ -285,14 +276,12 @@ TEST_F(ucg_step_test, test_msg_process) { memcpy(&desc->data[0], (void *) data, length); desc->super.flags = 0; desc->super.length = length; - desc->release_desc = release_desc; ucs_list_add_tail(&slot->msg_head, &desc->super.tag_list[0]); ret = ucg_builtin_msg_process(slot, &slot->req); ASSERT_EQ(UCS_OK, ret); for (int i = 0; i < count; i++) { ASSERT_EQ(-2, recv[i]); } - destroy_collective_params(params); } TEST_F(ucg_step_test, test_step_execute_short) { @@ -325,7 +314,6 @@ TEST_F(ucg_step_test, test_step_execute_short) { delete iface; step->uct_iface = NULL; ASSERT_EQ(UCS_OK, ret); - destroy_collective_params(params); } TEST_F(ucg_step_test, test_step_execute_bcopy) { @@ -360,9 +348,8 @@ TEST_F(ucg_step_test, test_step_execute_bcopy) { delete iface; step->uct_iface = NULL; ASSERT_EQ(UCS_OK, ret); - destroy_collective_params(params); - m_ucp_worker = NULL; - m_ucp_context = NULL; + m_ucg_worker = NULL; + m_ucg_context = NULL; } TEST_F(ucg_step_test, test_step_execute_zcopy) { @@ -400,10 +387,9 @@ TEST_F(ucg_step_test, test_step_execute_zcopy) { ret = ucg_builtin_step_execute(&slot->req, NULL); ASSERT_EQ(UCS_INPROGRESS, ret); - slot->mp = &m_ucp_worker->am_mp; + slot->mp = &m_ucg_worker->am_mp; ucg_builtin_comp_desc_t *desc = (ucg_builtin_comp_desc_t *) ucs_mpool_get_inline(slot->mp); ucs_list_add_tail(&slot->msg_head, &desc->super.tag_list[0]); - desc->release_desc = release_desc; step->zcopy.num_store = 0; ret = ucg_builtin_step_execute(&slot->req, NULL); @@ -411,7 +397,6 @@ TEST_F(ucg_step_test, test_step_execute_zcopy) { step->uct_iface = NULL; ASSERT_EQ(UCS_OK, ret); ASSERT_EQ((unsigned)0, step->zcopy.num_store); - destroy_collective_params(params); - m_ucp_worker = NULL; - m_ucp_context = NULL; + m_ucg_worker = NULL; + m_ucg_context = NULL; } diff --git a/test/gtest/ucg/test_topo_info.cc b/test/gtest/ucg/test_topo_info.cc index a493902ccb4..eb64efe0416 100644 --- a/test/gtest/ucg/test_topo_info.cc +++ b/test/gtest/ucg/test_topo_info.cc @@ -21,9 +21,7 @@ TEST_F(ucg_test, test_topo_info) { all_rank_infos.push_back(my_rank_info); all_rank_infos.push_back(other_rank_info); - ucg_group_params_t *group_params = m_resource_factory->create_group_params(my_rank_info, - all_rank_infos, - m_ucp_worker); + ucg_group_params_t *group_params = m_resource_factory->create_group_params(my_rank_info, all_rank_infos); ucg_builtin_topology_info_params_t *topo_params = (ucg_builtin_topology_info_params_t *) malloc( sizeof(ucg_builtin_topology_info_params_t)); diff --git a/test/gtest/ucg/test_ucg_context.cc b/test/gtest/ucg/test_ucg_context.cc index bab0659c3fa..6803a7fa306 100644 --- a/test/gtest/ucg/test_ucg_context.cc +++ b/test/gtest/ucg/test_ucg_context.cc @@ -9,15 +9,15 @@ using namespace std; class ucg_context_test : public ucg_test { public: - static ucp_params_t get_ctx_params() { - ucp_params_t params = get_ctx_params_inner(); + static ucg_params_t get_ctx_params() { + ucg_params_t params = get_ctx_params_inner(); params.features |= UCS_BIT(0) | UCS_BIT(4); return params; } protected: - static ucp_params_t get_ctx_params_inner() { - ucp_params_t params; + static ucg_params_t get_ctx_params_inner() { + ucg_params_t params; memset(¶ms, 0, sizeof(params)); params.field_mask |= UCS_BIT(0); return params; @@ -25,32 +25,32 @@ class ucg_context_test : public ucg_test { }; TEST(ucg_context_test, minimal_field_mask) { - ucs::handle config; - UCS_TEST_CREATE_HANDLE(ucp_config_t *, config, ucp_config_release, - ucp_config_read, NULL, NULL); + ucs::handle config; + UCS_TEST_CREATE_HANDLE(ucg_config_t *, config, ucg_config_release, + ucg_config_read, NULL, NULL); - ucs::handle ucgh; - ucs::handle worker; + ucs::handle ucgh; + ucs::handle worker; { /* Features ONLY */ - ucp_params_t params; + ucg_params_t params; VALGRIND_MAKE_MEM_UNDEFINED(¶ms, sizeof(params)); params.field_mask = UCS_BIT(0); params.features = ucg_context_test::get_ctx_params().features; - UCS_TEST_CREATE_HANDLE(ucp_context_h, ucgh, ucp_cleanup, - ucp_init, ¶ms, config.get()); + UCS_TEST_CREATE_HANDLE(ucg_context_h, ucgh, ucg_cleanup, + ucg_init, ¶ms, config.get()); } { /* Empty set */ - ucp_worker_params_t params; + ucg_worker_params_t params; VALGRIND_MAKE_MEM_UNDEFINED(¶ms, sizeof(params)); params.field_mask = 0; - UCS_TEST_CREATE_HANDLE(ucp_worker_h, worker, ucp_worker_destroy, - ucp_worker_create, ucgh.get(), ¶ms); + UCS_TEST_CREATE_HANDLE(ucg_worker_h, worker, ucg_worker_destroy, + ucg_worker_create, ucgh.get(), ¶ms); } } @@ -59,15 +59,15 @@ class ucg_version_test : public ucg_context_test { }; TEST_F(ucg_version_test, test_wrong_api_version) { - ucs::handle config; - UCS_TEST_CREATE_HANDLE(ucp_config_t *, config, ucp_config_release, - ucp_config_read, NULL, NULL); + ucs::handle config; + UCS_TEST_CREATE_HANDLE(ucg_config_t *, config, ucg_config_release, + ucg_config_read, NULL, NULL); - ucp_params_t params = get_ctx_params(); - ucp_context_h ucgh; + ucg_params_t params = get_ctx_params(); + ucg_context_h ucgh; ucs_status_t status; - status = ucp_init_version(99, 99, ¶ms, config.get(), &ucgh); + status = ucg_init_version(99, 99, ¶ms, config.get(), &ucgh); // TODO if (status != UCS_OK) { diff --git a/test/gtest/ucg/ucg_plan_test.h b/test/gtest/ucg/ucg_plan_test.h index 1061cd0b731..fddac3816f5 100644 --- a/test/gtest/ucg/ucg_plan_test.h +++ b/test/gtest/ucg/ucg_plan_test.h @@ -25,12 +25,12 @@ class ucg_plan_test : public ucg_test { public: vector m_all_rank_infos; - ucg_builtin_planner_ctx_t *m_builtin_ctx; + ucg_builtin_group_ctx_t *m_builtin_ctx; + ucg_plan_component_t *m_planc; ucg_group_params_t *m_group_params; ucg_collective_type_t m_coll_type; ucg_collective_params_t *m_coll_params; ucg_group_h m_group; - ucg_planner_h m_planner_p; }; diff --git a/test/gtest/ucg/ucg_test.cc b/test/gtest/ucg/ucg_test.cc index 6640c29d809..af31e4c74b7 100644 --- a/test/gtest/ucg/ucg_test.cc +++ b/test/gtest/ucg/ucg_test.cc @@ -9,44 +9,41 @@ using namespace std; -static ucs_status_t resolve_address_callback(void *cb_group_obj, ucg_group_member_index_t index, - ucp_address_t **addr, size_t *addr_len); -static ucg_group_member_index_t mpi_global_idx_dummy(void *cb_group_obj, ucg_group_member_index_t index); + static class ucg_resource_factory g_ucg_resource_factory; ucg_resource_factory *ucg_test::m_resource_factory = &g_ucg_resource_factory; ucg_test::ucg_test() { - m_ucp_context = NULL; m_ucg_context = NULL; - m_ucp_worker = NULL; + m_ucg_worker = NULL; + init_ucg_component(); } ucg_test::~ucg_test() { - if (m_ucp_worker != NULL) { - ucp_worker_destroy(m_ucp_worker); - m_ucp_worker = NULL; + if (m_ucg_worker != NULL) { + ucg_worker_destroy(m_ucg_worker); + m_ucg_worker = NULL; } + if (m_ucg_context != NULL) { ucg_cleanup(m_ucg_context); m_ucg_context = NULL; } - if (m_ucp_context != NULL) { - ucp_cleanup(m_ucp_context); - m_ucp_context = NULL; - } - } -void ucg_test::init_ucp() +void ucg_test::init_ucg_component() { - ucp_params_t params; - ucp_config_t *config = NULL; + ucg_params_t params; + ucg_config_t *config = NULL; + /* Read options */ - (void)ucp_config_read("MPI", NULL, &config); + (void)ucg_config_read("MPI", NULL, &config); + + /* Initialize UCX context */ params.field_mask = UCP_PARAM_FIELD_FEATURES | UCP_PARAM_FIELD_REQUEST_SIZE | UCP_PARAM_FIELD_REQUEST_INIT | @@ -59,57 +56,26 @@ void ucg_test::init_ucp() UCP_FEATURE_AMO32 | UCP_FEATURE_AMO64 | UCP_FEATURE_GROUPS; - /* Initialize UCX context */ - // params.request_size = sizeof(ompi_request_t); // params.request_init = mca_coll_ucx_request_init; // params.request_cleanup = mca_coll_ucx_request_cleanup; params.mt_workers_shared = 0; /* we do not need mt support for context since it will be protected by worker */ params.estimated_num_eps = 0; - (void)ucp_init(¶ms, config, &m_ucp_context); - ucp_config_release(config); -} -void ucg_test::init_ucg() -{ - ucg_params_t params; + (void)ucg_init(¶ms, config, &m_ucg_context); - params.field_mask = UCG_PARAM_FIELD_ADDRESS_CB | - UCG_PARAM_FIELD_REDUCE_CB | - UCG_PARAM_FIELD_COMMUTE_CB | - UCG_PARAM_FIELD_GLOBALIDX_CB | - UCG_PARAM_FIELD_DTCONVERT_CB | - UCG_PARAM_FIELD_DATATYPESPAN_CB | - UCG_PARAM_FIELD_MPI_IN_PLACE; - params.address.lookup_f = resolve_address_callback; - params.address.release_f = NULL; - params.mpi_reduce_f = NULL; - params.op_is_commute_f = ompi_op_is_commute; - params.mpi_global_idx_f = mpi_global_idx_dummy; - params.mpi_dt_convert = mca_coll_ucg_datatype_convert_for_ut; - params.mpi_datatype_span = NULL; - params.mpi_in_place = NULL; - ucg_init(¶ms, NULL, &m_ucg_context); -} + ucg_worker_params_t work_params; -void ucg_test::init_worker() -{ - ucp_worker_params_t params; - params.field_mask = UCP_WORKER_PARAM_FIELD_THREAD_MODE; - params.thread_mode = UCS_THREAD_MODE_MULTI; - ucp_worker_create(m_ucp_context, ¶ms, &m_ucp_worker); -} + /* TODO check MPI thread mode */ + work_params.field_mask = UCP_WORKER_PARAM_FIELD_THREAD_MODE; + work_params.thread_mode = UCS_THREAD_MODE_SINGLE; + work_params.thread_mode = UCS_THREAD_MODE_SINGLE; -void ucg_test::init_ucg_component() -{ - init_ucp(); - init_ucg(); - init_worker(); + (void)ucg_worker_create(m_ucg_context, &work_params, &m_ucg_worker); } -ucg_collective_type_t ucg_test::create_allreduce_coll_type() const -{ +ucg_collective_type_t ucg_test::create_allreduce_coll_type() const { ucg_collective_type_t type; type.modifiers = (ucg_collective_modifiers) (UCG_GROUP_COLLECTIVE_MODIFIER_AGGREGATE | UCG_GROUP_COLLECTIVE_MODIFIER_BROADCAST); @@ -117,8 +83,7 @@ ucg_collective_type_t ucg_test::create_allreduce_coll_type() const return type; } -ucg_collective_type_t ucg_test::create_bcast_coll_type() const -{ +ucg_collective_type_t ucg_test::create_bcast_coll_type() const { ucg_collective_type_t type; type.modifiers = (ucg_collective_modifiers) (UCG_GROUP_COLLECTIVE_MODIFIER_BROADCAST | UCG_GROUP_COLLECTIVE_MODIFIER_SINGLE_SOURCE); @@ -126,8 +91,7 @@ ucg_collective_type_t ucg_test::create_bcast_coll_type() const return type; } -ucg_collective_type_t ucg_test::create_barrier_coll_type() const -{ +ucg_collective_type_t ucg_test::create_barrier_coll_type() const { ucg_collective_type_t type; type.modifiers = (ucg_collective_modifiers) (UCG_GROUP_COLLECTIVE_MODIFIER_AGGREGATE | UCG_GROUP_COLLECTIVE_MODIFIER_BROADCAST | @@ -136,8 +100,7 @@ ucg_collective_type_t ucg_test::create_barrier_coll_type() const return type; } -ucg_collective_params_t *ucg_test::create_allreduce_params() const -{ +ucg_collective_params_t *ucg_test::create_allreduce_params() const { size_t count = 2; int *send_buf = new int[count]; int *recv_buf = new int[count]; @@ -153,28 +116,7 @@ ucg_collective_params_t *ucg_test::create_allreduce_params() const 0, send_buf, count, recv_buf, sizeof(int), NULL, op); } -void ucg_test::destroy_collective_params(ucg_collective_params_t *¶ms) const -{ - if (params != NULL) { - if (params->send.buf != NULL) { - delete [] (int *)params->send.buf; - params->send.buf = NULL; - } - if (params->recv.buf != NULL) { - delete [] (int *)params->recv.buf; - params->recv.buf = NULL; - } - if (params->recv.op_ext != NULL) { - delete (ucg_ompi_op *)params->recv.op_ext; - params->recv.op_ext = NULL; - } - } - delete params; - params = NULL; -} - -ucg_collective_params_t *ucg_test::create_bcast_params() const -{ +ucg_collective_params_t *ucg_test::create_bcast_params() const { size_t count = 2; int *send_buf = new int[count]; int *recv_buf = new int[count]; @@ -200,7 +142,8 @@ int mca_coll_ucg_datatype_convert_for_ut(void *mpi_dt, ucp_datatype_t *ucp_dt) ucg_builtin_config_t *ucg_resource_factory::create_config( unsigned bcast_alg, unsigned allreduce_alg, unsigned barrier_alg) { - ucg_builtin_config_t *config = new ucg_builtin_config_t(); + ucg_builtin_config_t *config = new ucg_builtin_config_t; + config->super.ft = UCG_PLAN_FT_IGNORE; config->bmtree.degree_inter_fanout = 8; config->bmtree.degree_inter_fanin = 8; @@ -223,8 +166,8 @@ ucg_builtin_config_t *ucg_resource_factory::create_config( return config; } -static ucs_status_t resolve_address_callback(void *cb_group_obj, ucg_group_member_index_t index, - ucp_address_t **addr, size_t *addr_len) +ucs_status_t resolve_address_callback(void *cb_group_obj, ucg_group_member_index_t index, + ucg_address_t **addr, size_t *addr_len) { *addr_len = 0; return UCS_OK; @@ -235,25 +178,22 @@ static ucg_group_member_index_t mpi_global_idx_dummy(void *cb_group_obj, ucg_gro return 0; } -ucg_group_params_t *ucg_resource_factory::create_group_params(ucg_rank_info my_rank_info, - const std::vector &rank_infos, - ucp_worker_h worker) +ucg_group_params_t *ucg_resource_factory::create_group_params( + ucg_rank_info my_rank_info, const std::vector &rank_infos) { ucg_group_params_t *args = new ucg_group_params_t(); - args->field_mask = UCG_GROUP_PARAM_FIELD_UCP_WORKER | - UCG_GROUP_PARAM_FIELD_ID | - UCG_GROUP_PARAM_FIELD_MEMBER_COUNT | - UCG_GROUP_PARAM_FIELD_DISTANCE | - UCG_GROUP_PARAM_FIELD_NODE_INDEX | - UCG_GROUP_PARAM_FIELD_BIND_TO_NONE | - UCG_GROUP_PARAM_FIELD_CB_GROUP_IBJ | - UCG_GROUP_PARAM_FIELD_IS_SOCKET_BALANCE; - args->ucp_worker = worker; args->member_count = rank_infos.size(); - args->group_id = 0; + args->cid = 0; + args->mpi_reduce_f = NULL; + args->resolve_address_f = &resolve_address_callback; + args->release_address_f = NULL; args->cb_group_obj = NULL; + args->op_is_commute_f = ompi_op_is_commute; + args->mpi_dt_convert = mca_coll_ucg_datatype_convert_for_ut; args->distance = (ucg_group_member_distance *) malloc(args->member_count * sizeof(*args->distance)); args->node_index = (uint16_t *) malloc(args->member_count * sizeof(*args->node_index)); + args->mpi_global_idx_f = mpi_global_idx_dummy; + for (size_t i = 0; i < rank_infos.size(); i++) { if (rank_infos[i].rank == my_rank_info.rank) { args->distance[rank_infos[i].rank] = UCG_GROUP_MEMBER_DISTANCE_SELF; @@ -273,11 +213,11 @@ ucg_group_params_t *ucg_resource_factory::create_group_params(ucg_rank_info my_r return args; } -ucs_status_t ucg_resource_factory::create_group(const ucg_group_params_t *params, - ucg_context_h context, - ucg_group_h *group) +ucg_group_h ucg_resource_factory::create_group(const ucg_group_params_t *params, ucg_worker_h ucg_worker) { - return ucg_group_create(context, params, group); + ucg_group_h group; + ucg_group_create(ucg_worker, params, &group); + return group; } ucg_collective_params_t *ucg_resource_factory::create_collective_params( diff --git a/test/gtest/ucg/ucg_test.h b/test/gtest/ucg/ucg_test.h index 3d7889880cb..d7e7ae714fc 100644 --- a/test/gtest/ucg/ucg_test.h +++ b/test/gtest/ucg/ucg_test.h @@ -9,11 +9,10 @@ #include #include #include -#include "ucg/builtin/builtin.h" #include "ucg/builtin/plan/builtin_plan.h" #include "ucg/builtin/ops/builtin_ops.h" -#include "ucg/base/ucg_component.h" #include "ucg/base/ucg_group.h" +#include "ucg/api/ucg_plan_component.h" #include "ucg/api/ucg.h" #if HAVE_CUDA @@ -33,9 +32,8 @@ class ucg_test : public ::testing::Test { virtual ~ucg_test(); - ucp_context_h m_ucp_context; ucg_context_h m_ucg_context; - ucp_worker_h m_ucp_worker; + ucg_worker_h m_ucg_worker; protected: void SetUp() override { @@ -44,9 +42,6 @@ class ucg_test : public ::testing::Test { void TearDown() override { } - void init_ucp(); - void init_ucg(); - void init_worker(); void init_ucg_component(); ucg_collective_type_t create_allreduce_coll_type() const; @@ -57,8 +52,6 @@ class ucg_test : public ::testing::Test { ucg_collective_params_t *create_allreduce_params() const; - void destroy_collective_params(ucg_collective_params_t *¶ms) const; - ucg_collective_params_t *create_bcast_params() const; static ucg_resource_factory *m_resource_factory; @@ -80,11 +73,9 @@ class ucg_resource_factory { public: ucg_builtin_config_t *create_config(unsigned bcast_alg, unsigned allreduce_alg, unsigned barrier_alg); - ucs_status_t create_group(const ucg_group_params_t *params, ucg_context_h context, ucg_group_h *group); + ucg_group_h create_group(const ucg_group_params_t *params, ucg_worker_h ucg_worker); - ucg_group_params_t *create_group_params(ucg_rank_info my_rank_info, - const std::vector &rank_infos, - ucp_worker_h worker); + ucg_group_params_t *create_group_params(ucg_rank_info my_rank_info, const std::vector &rank_infos); ucg_collective_params_t *create_collective_params(ucg_collective_modifiers modifiers, ucg_group_member_index_t root, diff --git a/test/gtest/uct/test_fence.cc b/test/gtest/uct/test_fence.cc index 0b4524dcddb..8644a7281a6 100644 --- a/test/gtest/uct/test_fence.cc +++ b/test/gtest/uct/test_fence.cc @@ -54,6 +54,8 @@ class uct_fence_test : public uct_test { return m_entities.at(0); } + static void completion_cb(uct_completion_t *self, ucs_status_t status) {} + class worker { public: worker(uct_fence_test* test, send_func_t send, recv_func_t recv, @@ -108,7 +110,7 @@ class uct_fence_test : public uct_test { private: void run() { uct_completion_t uct_comp; - uct_comp.func = (uct_completion_callback_t)ucs_empty_function; + uct_comp.func = completion_cb; for (unsigned i = 0; i < uct_fence_test::count(); i++) { uint64_t local_val = ucs::rand(); uint64_t remote_val = ucs::rand();