diff --git a/src/ucp/core/ucp_context.c b/src/ucp/core/ucp_context.c index ee44b4cc5f6..285d3199dd0 100644 --- a/src/ucp/core/ucp_context.c +++ b/src/ucp/core/ucp_context.c @@ -722,7 +722,8 @@ void ucp_config_release(ucp_config_t *config) ucs_status_t ucp_config_modify_internal(ucp_config_t *config, const char *name, const char *value) { - return ucs_config_parser_set_value(config, ucp_config_table, name, value); + return ucs_config_parser_set_value(config, ucp_config_table, NULL, name, + value); } ucs_status_t ucp_config_modify(ucp_config_t *config, const char *name, diff --git a/src/ucs/config/global_opts.c b/src/ucs/config/global_opts.c index 297770424ee..3fd564edd29 100644 --- a/src/ucs/config/global_opts.c +++ b/src/ucs/config/global_opts.c @@ -326,16 +326,15 @@ ucs_status_t ucs_global_opts_set_value(const char *name, const char *value) } return ucs_config_parser_set_value(&ucs_global_opts, - ucs_global_opts_read_only_table, + ucs_global_opts_read_only_table, NULL, name, value); } ucs_status_t ucs_global_opts_set_value_modifiable(const char *name, const char *value) { - return ucs_config_parser_set_value(&ucs_global_opts, - ucs_global_opts_table, name, - value); + return ucs_config_parser_set_value(&ucs_global_opts, ucs_global_opts_table, + NULL, name, value); } ucs_status_t ucs_global_opts_get_value(const char *name, char *value, diff --git a/src/ucs/config/parser.c b/src/ucs/config/parser.c index 0d75f62e921..3662e78da46 100644 --- a/src/ucs/config/parser.c +++ b/src/ucs/config/parser.c @@ -1560,9 +1560,11 @@ ucs_config_parser_fill_opts(void *opts, ucs_config_global_list_entry_t *entry, } ucs_status_t ucs_config_parser_set_value(void *opts, ucs_config_field_t *fields, - const char *name, const char *value) + const char *prefix, const char *name, + const char *value) { - return ucs_config_parser_set_value_internal(opts, fields, name, value, NULL, 1); + return ucs_config_parser_set_value_internal(opts, fields, name, value, + prefix, 1); } ucs_status_t ucs_config_parser_get_value(void *opts, ucs_config_field_t *fields, diff --git a/src/ucs/config/parser.h b/src/ucs/config/parser.h index 051f4e9223a..3a8356e28ca 100644 --- a/src/ucs/config/parser.h +++ b/src/ucs/config/parser.h @@ -522,11 +522,13 @@ ucs_status_t ucs_config_parser_get_value(void *opts, ucs_config_field_t *fields, * * @param opts User-defined options structure. * @param fields Array of fields which define how to parse. + * @param prefix Configuration table prefix. * @param name Option name to modify. * @param value Value to assign. */ ucs_status_t ucs_config_parser_set_value(void *opts, ucs_config_field_t *fields, - const char *name, const char *value); + const char *prefix, const char *name, + const char *value); /** * Wrapper for `ucs_config_parser_print_env_vars` diff --git a/src/uct/base/uct_md.c b/src/uct/base/uct_md.c index 04563ec032c..6673abbce97 100644 --- a/src/uct/base/uct_md.c +++ b/src/uct/base/uct_md.c @@ -297,7 +297,8 @@ ucs_status_t uct_config_get(void *config, const char *name, char *value, ucs_status_t uct_config_modify(void *config, const char *name, const char *value) { uct_config_bundle_t *bundle = (uct_config_bundle_t *)config - 1; - return ucs_config_parser_set_value(bundle->data, bundle->table, name, value); + return ucs_config_parser_set_value(bundle->data, bundle->table, + bundle->table_prefix, name, value); } static ucs_status_t diff --git a/test/gtest/ucp/test_ucp_request.cc b/test/gtest/ucp/test_ucp_request.cc index 30711c6cd65..7e0d29a1940 100644 --- a/test/gtest/ucp/test_ucp_request.cc +++ b/test/gtest/ucp/test_ucp_request.cc @@ -8,7 +8,9 @@ #include "ucp_test.h" #include extern "C" { +#include #include +#include } @@ -100,3 +102,393 @@ UCS_TEST_P(test_ucp_request, test_request_query) } UCP_INSTANTIATE_TEST_CASE_TLS(test_ucp_request, all, "all") + +class test_proto_reset : public ucp_test { +public: + typedef enum { + TAG, + RMA_GET, + RMA_PUT, + STREAM, + AM + } operation_t; + + test_proto_reset() : m_completed(false), m_am_cb_cnt(0) + { + } + + void init() override + { + if (!m_ucp_config->ctx.proto_enable) { + UCS_TEST_SKIP_R("reset is not supported for proto v1"); + } + + if (is_self()) { + UCS_TEST_SKIP_R("self transport has no pending queue"); + } + + ucp_test::init(); + modify_config("TCP_SNDBUF", "8K", IGNORE_IF_NOT_EXIST); + modify_config("IB_TX_QUEUE_LEN", "65", IGNORE_IF_NOT_EXIST); + create_entity(true); + + sender().connect(&receiver(), get_ep_params()); + receiver().connect(&sender(), get_ep_params()); + } + + void cleanup() override + { + m_rkeys.clear(); + m_rbufs.clear(); + ucp_test::cleanup(); + } + + void get_stream_data(mapped_buffer &rbuf) + { + size_t roffset = 0; + ucp_request_param_t param = {0}; + constexpr double timeout = 10; + const ucs_time_t deadline = ucs::get_deadline(timeout); + size_t length; + ucs_status_ptr_t request; + ucs_status_t status; + + param.op_attr_mask = UCP_OP_ATTR_FIELD_DATATYPE; + param.datatype = ucp_dt_make_contig(1); + + do { + progress(); + request = ucp_stream_recv_nbx(receiver().ep(), + (uint8_t*)rbuf.ptr() + roffset, + rbuf.size() - roffset, &length, + ¶m); + ASSERT_FALSE(UCS_PTR_IS_ERR(request)); + + if (UCS_PTR_IS_PTR(request)) { + do { + progress(); + status = ucp_stream_recv_request_test(request, &length); + + } while ((status == UCS_INPROGRESS) && + (ucs_get_time() < deadline)); + ASSERT_UCS_OK(status); + ucp_request_free(request); + } + + roffset += length; + } while (roffset < rbuf.size()); + } + + static ucs_status_t + am_data_cb(void *arg, const void *header, size_t header_length, void *data, + size_t length, const ucp_am_recv_param_t *param) + { + test_proto_reset *self = (test_proto_reset*)arg; + + ucs_assert(length == self->m_rbufs[self->m_am_cb_cnt]->size()); + memcpy(self->m_rbufs[self->m_am_cb_cnt]->ptr(), data, length); + self->m_am_cb_cnt++; + return UCS_OK; + } + + void *send_am(std::vector &sbuf) + { + ucp_request_param_t req_param = {0}; + static unsigned am_id = 1; + ucp_am_handler_param_t param; + void *sreq; + + param.field_mask = UCP_AM_HANDLER_PARAM_FIELD_ID | + UCP_AM_HANDLER_PARAM_FIELD_CB | + UCP_AM_HANDLER_PARAM_FIELD_ARG; + param.id = am_id; + param.cb = am_data_cb; + param.arg = this; + + ucs_status_t status; + status = ucp_worker_set_am_recv_handler(receiver().worker(), ¶m); + ASSERT_UCS_OK(status); + + sreq = ucp_am_send_nbx(sender().ep(), am_id, NULL, 0, sbuf.data(), + sbuf.size(), &req_param); + am_id++; + return sreq; + } + + static void flushed_cb(ucp_request_t *request) + { + test_proto_reset *self = static_cast( + request->user_data); + + self->m_completed = true; + ucp_request_complete_send(request, request->status); + } + + static void purge_enqueue_cb(uct_pending_req_t *uct_req, void *arg) + { + ucp_request_t *req = ucs_container_of(uct_req, ucp_request_t, send.uct); + test_proto_reset *self; + + self = static_cast(arg); + self->m_pending.push_back(req); + } + + void restart(ucp_ep_h ep) + { + ucp_request_param_t param; + param.op_attr_mask = UCP_OP_ATTR_FIELD_USER_DATA | + UCP_OP_ATTR_FIELD_CALLBACK, + param.user_data = this; + param.cb.send = (ucp_send_nbx_callback_t)ucs_empty_function; + + ucp_ep_purge_lanes(ep, purge_enqueue_cb, this); + void *request = ucp_ep_flush_internal(ep, 0, ¶m, NULL, flushed_cb, + "ep_restart"); + + ASSERT_FALSE(UCS_PTR_IS_ERR(request)); + if (request != NULL) { + wait_for_value(&m_completed, true); + ucp_request_release(request); + } + + unsigned restart_count = 0; + + UCP_WORKER_THREAD_CS_ENTER_CONDITIONAL(ep->worker); + for (auto &req : m_pending) { + if (req->send.state.dt_iter.offset > 0) { + ucp_request_send(req); + } else { + ucp_proto_request_restart(req); + restart_count++; + } + } + UCP_WORKER_THREAD_CS_EXIT_CONDITIONAL(ep->worker); + + EXPECT_GT(restart_count, 0); + } + + void send_nb(std::vector &sbuf, mapped_buffer *rbuf, + operation_t op, bool sync, std::vector &reqs) + { + ucp_request_param_t param = {0}; + void *rreq = NULL; + void *sreq = NULL; + ucs::fill_random(sbuf); + + switch (op) { + case TAG: + param.op_attr_mask = UCP_OP_ATTR_FLAG_NO_IMM_CMPL; + sreq = (sync ? ucp_tag_send_sync_nbx : + ucp_tag_send_nbx)(sender().ep(), sbuf.data(), + sbuf.size(), 0, ¶m); + rreq = ucp_tag_recv_nbx(receiver().worker(), rbuf->ptr(), + rbuf->size(), 0, 0, ¶m); + ASSERT_FALSE(UCS_PTR_IS_ERR(rreq)); + reqs.push_back(rreq); + break; + case RMA_GET: + param.op_attr_mask = UCP_OP_ATTR_FLAG_NO_IMM_CMPL; + m_rkeys.push_back(rbuf->rkey(sender())); + sreq = ucp_get_nbx(sender().ep(), sbuf.data(), sbuf.size(), + (uint64_t)rbuf->ptr(), m_rkeys.back(), ¶m); + break; + case RMA_PUT: + m_rkeys.push_back(rbuf->rkey(sender())); + sreq = ucp_put_nbx(sender().ep(), sbuf.data(), sbuf.size(), + (uint64_t)rbuf->ptr(), m_rkeys.back(), ¶m); + break; + case STREAM: + param.op_attr_mask = UCP_OP_ATTR_FIELD_DATATYPE; + param.datatype = ucp_dt_make_contig(1); + sreq = ucp_stream_send_nbx(sender().ep(), sbuf.data(), sbuf.size(), + ¶m); + break; + case AM: + sreq = send_am(sbuf); + break; + } + + ASSERT_FALSE(UCS_PTR_IS_ERR(sreq)); + reqs.push_back(sreq); + } + + void wait_recv(operation_t op, std::vector &reqs) + { + if (op == STREAM) { + for (unsigned i = 0; i < reqs.size(); ++i) { + get_stream_data(*m_rbufs[i].get()); + } + } else if (op == AM) { + wait_for_value(&m_am_cb_cnt, reqs.size()); + } + + requests_wait(reqs); + } + + void send_requests(unsigned reqs_count, std::vector &reqs, + operation_t op, bool sync) + { + reqs.clear(); + m_am_cb_cnt = 0; + + for (int i = 0; i < reqs_count; ++i) { + send_nb(m_sbufs[i], m_rbufs[i].get(), op, sync, reqs); + } + } + + void reset_protocol(operation_t op, bool sync = false) + { + static const unsigned reqs_count = 1000; + static const size_t msg_size = UCS_KBYTE * 64; + + for (int i = 0; i < reqs_count; ++i) { + mapped_buffer *rbuf = new mapped_buffer(msg_size, receiver()); + rbuf->memset(0); + m_rbufs.push_back(std::unique_ptr(rbuf)); + m_sbufs.push_back(std::vector(msg_size)); + } + + /* Send a single message to complete wireup before sending actual + data */ + std::vector reqs; + send_requests(1, reqs, op, sync); + wait_recv(op, reqs); + + /* Send all messages */ + send_requests(reqs_count, reqs, op, sync); + restart(sender().ep()); + wait_recv(op, reqs); + flush_ep(sender()); + + for (int i = 0; i < reqs_count; ++i) { + auto rbuf = (uint8_t*)m_rbufs[i]->ptr(); + std::vector rvec(rbuf, rbuf + m_rbufs[i]->size()); + EXPECT_EQ(m_sbufs[i], rvec); + } + } + + void skip_no_pending_rma() + { + const auto config = ucp_ep_config(sender().ep()); + static const std::vector np_tls = {"cma", "knem", "xpmem", + "sysv", "posix"}; + + for (ucp_lane_index_t i = 0; i < config->key.num_lanes; ++i) { + const auto lane = config->key.rma_bw_lanes[i]; + if (lane == UCP_NULL_LANE) { + break; + } + + auto tl_name = ucp_ep_get_tl_rsc(sender().ep(), lane)->tl_name; + if (std::find(np_tls.begin(), np_tls.end(), tl_name) != + np_tls.end()) { + UCS_TEST_SKIP_R("RMA transport does not support pending queue"); + } + } + } + + static void get_test_variants(std::vector &variants) + { + add_variant_with_value(variants, + UCP_FEATURE_TAG | UCP_FEATURE_RMA | + UCP_FEATURE_STREAM | UCP_FEATURE_AM, + 0, ""); + } + +protected: + std::vector> m_sbufs; + std::vector> m_rbufs; + std::vector> m_rkeys; + bool m_completed; + size_t m_am_cb_cnt; + std::vector m_pending; +}; + +UCS_TEST_P(test_proto_reset, tag_eager_multi_bcopy, "ZCOPY_THRESH=inf", + "RNDV_THRESH=inf") +{ + reset_protocol(TAG); +} + +UCS_TEST_P(test_proto_reset, get_offload_bcopy_to_get_am_bcopy, + "ZCOPY_THRESH=inf", "RNDV_THRESH=inf") +{ + skip_no_pending_rma(); + reset_protocol(RMA_GET); +} + +UCS_TEST_P(test_proto_reset, put_offload_bcopy_to_put_am_bcopy, + "ZCOPY_THRESH=inf", "RNDV_THRESH=inf") +{ + skip_no_pending_rma(); + reset_protocol(RMA_PUT); +} + +UCS_TEST_P(test_proto_reset, stream_multi_bcopy, "ZCOPY_THRESH=inf", + "RNDV_THRESH=inf") +{ + reset_protocol(STREAM); +} + +UCS_TEST_P(test_proto_reset, rndv_am_bcopy, "ZCOPY_THRESH=inf", "RNDV_THRESH=0", + "RNDV_SCHEME=am") +{ + reset_protocol(TAG); +} + +UCS_TEST_P(test_proto_reset, eager_sync_multi_bcopy, "ZCOPY_THRESH=inf", + "RNDV_THRESH=inf") +{ + reset_protocol(TAG, true); +} + +UCS_TEST_P(test_proto_reset, am_eager_multi_bcopy, "ZCOPY_THRESH=inf", + "RNDV_THRESH=inf") +{ + reset_protocol(AM); +} + +UCS_TEST_P(test_proto_reset, tag_eager_multi_zcopy_to_bcopy, "ZCOPY_THRESH=0", + "RNDV_THRESH=inf") +{ + reset_protocol(TAG); +} + +UCS_TEST_P(test_proto_reset, get_offload_zcopy_to_get_am_bcopy, + "ZCOPY_THRESH=0", "RNDV_THRESH=inf") +{ + skip_no_pending_rma(); + reset_protocol(RMA_GET); +} + +UCS_TEST_P(test_proto_reset, put_offload_zcopy_to_put_am_bcopy, + "ZCOPY_THRESH=0", "RNDV_THRESH=inf") +{ + skip_no_pending_rma(); + reset_protocol(RMA_PUT); +} + +UCS_TEST_P(test_proto_reset, stream_multi_zcopy_to_bcopy, "ZCOPY_THRESH=0", + "RNDV_THRESH=inf") +{ + reset_protocol(STREAM); +} + +UCS_TEST_P(test_proto_reset, rndv_am_zcopy_to_bcopy, "ZCOPY_THRESH=0", + "RNDV_THRESH=0", "RNDV_SCHEME=am") +{ + reset_protocol(TAG); +} + +UCS_TEST_P(test_proto_reset, am_eager_multi_zcopy_to_bcopy, "ZCOPY_THRESH=0", + "RNDV_THRESH=inf") +{ + reset_protocol(AM); +} + +UCS_TEST_P(test_proto_reset, rndv_put, "RNDV_THRESH=0", "RNDV_SCHEME=put_zcopy") +{ + reset_protocol(TAG); +} + +UCP_INSTANTIATE_TEST_CASE(test_proto_reset) diff --git a/test/gtest/ucp/test_ucp_wireup.cc b/test/gtest/ucp/test_ucp_wireup.cc index accd9eddb9c..4e5a2a810ed 100644 --- a/test/gtest/ucp/test_ucp_wireup.cc +++ b/test/gtest/ucp/test_ucp_wireup.cc @@ -84,22 +84,6 @@ class test_ucp_wireup : public ucp_test { bool ep_iface_has_caps(const entity& e, const std::string& tl, uint64_t caps); - size_t count_resources(const ucp_test_base::entity &e, - const std::string &tl_name) const - { - return std::count_if(e.ucph()->tl_rscs, - e.ucph()->tl_rscs + e.ucph()->num_tls, - [&](const ucp_tl_resource_desc_t &rsc) { - return tl_name == rsc.tl_rsc.tl_name; - }); - } - - bool has_resource(const ucp_test_base::entity &e, - const std::string &tl_name) const - { - return count_resources(e, tl_name) != 0; - } - protected: vec_type m_send_data; vec_type m_recv_data; diff --git a/test/gtest/ucp/ucp_test.cc b/test/gtest/ucp/ucp_test.cc index 6f7a66033e2..c03a777a7c1 100644 --- a/test/gtest/ucp/ucp_test.cc +++ b/test/gtest/ucp/ucp_test.cc @@ -1268,3 +1268,19 @@ bool ucp_test::check_reg_mem_types(const entity& e, ucs_memory_type_t mem_type) return false; } + +size_t ucp_test::count_resources(const ucp_test_base::entity &e, + const std::string &tl_name) const +{ + return std::count_if(e.ucph()->tl_rscs, + e.ucph()->tl_rscs + e.ucph()->num_tls, + [&](const ucp_tl_resource_desc_t &rsc) { + return tl_name == rsc.tl_rsc.tl_name; + }); +} + +bool ucp_test::has_resource(const ucp_test_base::entity &e, + const std::string &tl_name) const +{ + return count_resources(e, tl_name) != 0; +} diff --git a/test/gtest/ucp/ucp_test.h b/test/gtest/ucp/ucp_test.h index b49ca202987..dc22c8bb73d 100644 --- a/test/gtest/ucp/ucp_test.h +++ b/test/gtest/ucp/ucp_test.h @@ -237,6 +237,10 @@ class ucp_test : public ucp_test_base, virtual bool has_transport(const std::string& tl_name) const; bool has_any_transport(const std::vector& tl_names) const; bool has_any_transport(const std::string *tls, size_t tl_size) const; + size_t count_resources(const ucp_test_base::entity &e, + const std::string &tl_name) const; + bool has_resource(const ucp_test_base::entity &e, + const std::string &tl_name) const; entity* create_entity(bool add_in_front = false); entity* create_entity(bool add_in_front, const ucp_test_param& test_param); unsigned progress(const std::vector &entities, diff --git a/test/gtest/ucs/test_config.cc b/test/gtest/ucs/test_config.cc index b8ba88f0720..a94fd1ffabb 100644 --- a/test/gtest/ucs/test_config.cc +++ b/test/gtest/ucs/test_config.cc @@ -308,7 +308,8 @@ class test_config : public ucs::test { } void set(const char *name, const char *value) { - ucs_config_parser_set_value(&m_opts, car_opts_table, name, value); + ucs_config_parser_set_value(&m_opts, car_opts_table, NULL, name, + value); } const char* get(const char *name) { diff --git a/test/gtest/uct/ib/test_ib.cc b/test/gtest/uct/ib/test_ib.cc index 1b8ffb2d121..a70828fe8ff 100644 --- a/test/gtest/uct/ib/test_ib.cc +++ b/test/gtest/uct/ib/test_ib.cc @@ -404,7 +404,7 @@ class test_uct_ib_gid_idx : public test_uct_ib_with_specific_port { } }; -UCS_TEST_P(test_uct_ib_gid_idx, non_default_gid_idx, "GID_INDEX=1") { +UCS_TEST_P(test_uct_ib_gid_idx, non_default_gid_idx, "IB_GID_INDEX=1") { send_recv_short(); } diff --git a/test/gtest/uct/ib/test_ib_md.cc b/test/gtest/uct/ib/test_ib_md.cc index 0839727a46d..c57fbcc1a7d 100644 --- a/test/gtest/uct/ib/test_ib_md.cc +++ b/test/gtest/uct/ib/test_ib_md.cc @@ -149,7 +149,7 @@ UCS_TEST_P(test_ib_md, ib_md_umr_ksm) { ib_md_umr_check(&rkey_buffer[0], has_ksm(), UCT_IB_MD_MAX_MR_SIZE + 0x1000); } -UCS_TEST_P(test_ib_md, relaxed_order, "PCI_RELAXED_ORDERING=try") { +UCS_TEST_P(test_ib_md, relaxed_order, "IB_PCI_RELAXED_ORDERING=try") { std::string rkey_buffer(md_attr().rkey_packed_size, '\0'); ib_md_umr_check(&rkey_buffer[0], false); @@ -229,8 +229,8 @@ UCS_TEST_P(test_ib_md, smkey_reg_atomic) test_smkey_reg_atomic(); } -UCS_TEST_P(test_ib_md, smkey_reg_atomic_mt, "REG_MT_THRESH=1k", - "REG_MT_CHUNK=1k") +UCS_TEST_P(test_ib_md, smkey_reg_atomic_mt, "IB_REG_MT_THRESH=1k", + "IB_REG_MT_CHUNK=1k") { test_smkey_reg_atomic(); } diff --git a/test/gtest/uct/ib/test_ib_xfer.cc b/test/gtest/uct/ib/test_ib_xfer.cc index 952105a152c..75710045b8b 100644 --- a/test/gtest/uct/ib/test_ib_xfer.cc +++ b/test/gtest/uct/ib/test_ib_xfer.cc @@ -12,7 +12,7 @@ class uct_p2p_rma_test_xfer : public uct_p2p_rma_test {}; UCS_TEST_SKIP_COND_P(uct_p2p_rma_test_xfer, fence_relaxed_order, !check_caps(UCT_IFACE_FLAG_PUT_BCOPY), - "PCI_RELAXED_ORDERING=try") { + "IB_PCI_RELAXED_ORDERING=try") { size_t size = ucs_min(ucs_get_page_size(), sender().iface_attr().cap.put.max_bcopy); @@ -65,7 +65,7 @@ UCS_TEST_SKIP_COND_P(uct_p2p_rma_test_inlresp, get_zcopy_inlresp0, /* test mlx5dv_create_qp() */ UCS_TEST_SKIP_COND_P(uct_p2p_rma_test_inlresp, get_zcopy_inlresp0_devx_no, !check_caps(UCT_IFACE_FLAG_GET_ZCOPY), - "IB_TX_INLINE_RESP=0", "MLX5_DEVX=n") { + "IB_TX_INLINE_RESP=0", "IB_MLX5_DEVX=n") { EXPECT_EQ(1u, sender().iface_attr().cap.get.min_zcopy); test_xfer_multi(static_cast(&uct_p2p_rma_test::get_zcopy), sender().iface_attr().cap.get.min_zcopy, @@ -113,7 +113,8 @@ UCS_TEST_SKIP_COND_P(uct_p2p_rma_test_alloc_methods, xfer_reg, UCS_TEST_SKIP_COND_P(uct_p2p_rma_test_alloc_methods, xfer_reg_multithreaded, !check_caps(UCT_IFACE_FLAG_PUT_ZCOPY | UCT_IFACE_FLAG_GET_ZCOPY), - "REG_MT_THRESH=1", "REG_MT_CHUNK=1G", "REG_MT_BIND=y") + "IB_REG_MT_THRESH=1", "IB_REG_MT_CHUNK=1G", + "IB_REG_MT_BIND=y") { test_put_zcopy(); test_get_zcopy(); @@ -130,7 +131,7 @@ UCS_TEST_P(uct_p2p_mix_test_alloc_methods, mix1000) } UCS_TEST_P(uct_p2p_mix_test_alloc_methods, mix1000_multithreaded, - "REG_MT_THRESH=1", "REG_MT_CHUNK=1K", "REG_MT_BIND=y") + "IB_REG_MT_THRESH=1", "IB_REG_MT_CHUNK=1K", "IB_REG_MT_BIND=y") { run(1000); } @@ -141,7 +142,7 @@ UCT_INSTANTIATE_IB_TEST_CASE(uct_p2p_mix_test_alloc_methods) class uct_p2p_mix_test_indirect_atomic : public uct_p2p_mix_test {}; UCS_TEST_P(uct_p2p_mix_test_indirect_atomic, mix1000_indirect_atomic, - "INDIRECT_ATOMIC=n") + "IB_INDIRECT_ATOMIC=n") { run(1000); } diff --git a/test/gtest/uct/ib/test_rc.cc b/test/gtest/uct/ib/test_rc.cc index c769926baaa..aa1b6a8960f 100644 --- a/test/gtest/uct/ib/test_rc.cc +++ b/test/gtest/uct/ib/test_rc.cc @@ -119,7 +119,7 @@ class test_rc_max_wr : public test_rc { protected: virtual void init() { ucs_status_t status1, status2; - status1 = uct_config_modify(m_iface_config, "TX_MAX_WR", "32"); + status1 = uct_config_modify(m_iface_config, "RC_VERBS_TX_MAX_WR", "32"); status2 = uct_config_modify(m_iface_config, "RC_TX_MAX_BB", "32"); if (status1 != UCS_OK && status2 != UCS_OK) { UCS_TEST_ABORT("Error: cannot set rc max wr/bb"); diff --git a/test/gtest/uct/tcp/test_tcp.cc b/test/gtest/uct/tcp/test_tcp.cc index a5abfd69dab..d5900cbb1b9 100644 --- a/test/gtest/uct/tcp/test_tcp.cc +++ b/test/gtest/uct/tcp/test_tcp.cc @@ -15,8 +15,8 @@ class test_uct_tcp : public uct_test { public: void init() { if (RUNNING_ON_VALGRIND) { - modify_config("TX_SEG_SIZE", "1kb"); - modify_config("RX_SEG_SIZE", "1kb"); + modify_config("TCP_TX_SEG_SIZE", "1kb"); + modify_config("TCP_RX_SEG_SIZE", "1kb"); } uct_test::init(); diff --git a/test/gtest/uct/test_many2one_am.cc b/test/gtest/uct/test_many2one_am.cc index 55a2ddd4b66..c281ad6da6b 100644 --- a/test/gtest/uct/test_many2one_am.cc +++ b/test/gtest/uct/test_many2one_am.cc @@ -31,8 +31,8 @@ class test_many2one_am : public uct_test { if (has_ib()) { tx_name = "IB_SEG_SIZE"; } else if (has_transport("tcp")) { - tx_name = "TX_SEG_SIZE"; - rx_name = "RX_SEG_SIZE"; + tx_name = "TCP_TX_SEG_SIZE"; + rx_name = "TCP_RX_SEG_SIZE"; } else if (has_transport("mm") || has_transport("self")) { tx_name = "SEG_SIZE"; diff --git a/test/gtest/uct/test_md.cc b/test/gtest/uct/test_md.cc index 256797a026b..0384af86276 100644 --- a/test/gtest/uct/test_md.cc +++ b/test/gtest/uct/test_md.cc @@ -1136,7 +1136,7 @@ class test_md_non_blocking : public test_md protected: void init() override { /* ODPv1 IB feature can work only for certain DEVX configuration */ - modify_config("MLX5_DEVX_OBJECTS", "dct,dcsrq", IGNORE_IF_NOT_EXIST); + modify_config("IB_MLX5_DEVX_OBJECTS", "dct,dcsrq", IGNORE_IF_NOT_EXIST); test_md::init(); } }; diff --git a/test/gtest/uct/test_mm.cc b/test/gtest/uct/test_mm.cc index 2c0522dfb1f..960d87b39fb 100644 --- a/test/gtest/uct/test_mm.cc +++ b/test/gtest/uct/test_mm.cc @@ -77,7 +77,7 @@ class test_uct_mm : public uct_test { } void set_posix_config() { - set_config("DIR=" + GetParam()->shm_dir); + set_config("POSIX_DIR=" + GetParam()->shm_dir); } virtual void init() { diff --git a/test/gtest/uct/test_tag.cc b/test/gtest/uct/test_tag.cc index c96b81385ca..23ba36ad445 100644 --- a/test/gtest/uct/test_tag.cc +++ b/test/gtest/uct/test_tag.cc @@ -1018,7 +1018,8 @@ void test_tag_mp_xrq::init() set_env_var_or_skip(m_iface_config, "RC_TM_ENABLE", "y"); set_env_var_or_skip(m_iface_config, "RC_TM_MP_SRQ_ENABLE", "try"); set_env_var_or_skip(m_iface_config, "RC_TM_MP_NUM_STRIDES", "8"); - set_env_var_or_skip(m_md_config, "MLX5_DEVX_OBJECTS", "dct,dcsrq,rcsrq,rcqp"); + set_env_var_or_skip(m_md_config, "IB_MLX5_DEVX_OBJECTS", + "dct,dcsrq,rcsrq,rcqp"); uct_test::init(); diff --git a/test/gtest/uct/uct_test.cc b/test/gtest/uct/uct_test.cc index 20585b0322f..ac015ab3777 100644 --- a/test/gtest/uct/uct_test.cc +++ b/test/gtest/uct/uct_test.cc @@ -814,8 +814,8 @@ void uct_test::reduce_tl_send_queues() set_config("RC_TX_QUEUE_LEN?=32"); set_config("UD_TX_QUEUE_LEN?=128"); set_config("RC_FC_ENABLE?=n"); - set_config("SNDBUF?=1k"); - set_config("RCVBUF?=128"); + set_config("TCP_SNDBUF?=1k"); + set_config("TCP_RCVBUF?=128"); } uct_test::entity::entity(const resource& resource, uct_iface_config_t *iface_config,