TEST: add mpi dyn seg alltoallv test

Author: wfaderhold21

test/mpi/test_alltoallv.cc

@@ -25,8 +25,9 @@ TestAlltoallv::TestAlltoallv(ucc_test_team_t &_team, TestCaseParams &params) :
     std::default_random_engine eng;
     size_t                     dt_size, count;
     int                        rank, nprocs, rank_count;
-    bool                       is_onesided;
     void                      *work_buf;
+    bool                       is_onesided;
+    bool                       use_dynamic_segments;
 
     dt          = params.dt;
     dt_size     = ucc_dt_size(dt);
@@ -44,13 +45,17 @@ TestAlltoallv::TestAlltoallv(ucc_test_team_t &_team, TestCaseParams &params) :
     count_bits  = params.count_bits;
     displ_bits  = params.displ_bits;
     is_onesided = (params.buffers != NULL);
+    /* Dynamic segments are enabled when buffers are provided but
+     * use_dynamic_segments is set */
+    use_dynamic_segments = is_onesided && params.use_dynamic_segments;
     work_buf    = NULL;
 
     std::uniform_int_distribution<int> urd(count / 2, count);
     eng.seed(test_rand_seed);
 
     MPI_Comm_rank(team.comm, &rank);
     MPI_Comm_size(team.comm, &nprocs);
+    //MPI_Barrier(team.comm);
 
     if (TEST_SKIP_NONE != skip_reduce(test_max_size < (msgsize * nprocs),
                                       TEST_SKIP_MEM_LIMIT, team.comm)) {
@@ -62,7 +67,10 @@ TestAlltoallv::TestAlltoallv(ucc_test_team_t &_team, TestCaseParams &params) :
                   UCC_COLL_ARGS_FLAG_CONTIG_DST_BUFFER;
     if (is_onesided) {
         args.mask  |= UCC_COLL_ARGS_FIELD_GLOBAL_WORK_BUFFER;
-        args.flags |= UCC_COLL_ARGS_FLAG_MEM_MAPPED_BUFFERS;
+        /* For dynamic segments, do not set MEM_MAPPED_BUFFERS flag */
+        if (!use_dynamic_segments) {
+            args.flags |= UCC_COLL_ARGS_FLAG_MEM_MAPPED_BUFFERS;
+        }
     }
     if (count_bits == TEST_FLAG_VSIZE_64BIT) {
         args.flags |= UCC_COLL_ARGS_FLAG_COUNT_64BIT;
@@ -103,23 +111,27 @@ TestAlltoallv::TestAlltoallv(ucc_test_team_t &_team, TestCaseParams &params) :
     check_buf = ucc_malloc(rncounts * dt_size, "check buf");
     UCC_MALLOC_CHECK(check_buf);
 
-    if (!is_onesided) {
+    if (!is_onesided || (is_onesided && use_dynamic_segments)) {
         UCC_CHECK(ucc_mc_alloc(&sbuf_mc_header, sncounts * dt_size, mem_type));
         UCC_CHECK(ucc_mc_alloc(&rbuf_mc_header, rncounts * dt_size, mem_type));
         sbuf = sbuf_mc_header->addr;
         rbuf = rbuf_mc_header->addr;
     } else {
-        sbuf                    = params.buffers[MEM_SEND_SEGMENT];
-        rbuf                    = params.buffers[MEM_RECV_SEGMENT];
+        /* Traditional onesided: use pre-mapped buffers */
+        sbuf = params.buffers[MEM_SEND_SEGMENT];
+        rbuf = params.buffers[MEM_RECV_SEGMENT];
+    }
+
+    if (is_onesided) {
         work_buf                = params.buffers[MEM_WORK_SEGMENT];
         args.global_work_buffer = work_buf;
     }
 
-    args.src.info_v.buffer = sbuf;
+    args.src.info_v.buffer   = sbuf;
     args.src.info_v.datatype = dt;
     args.src.info_v.mem_type = mem_type;
 
-    args.dst.info_v.buffer = rbuf;
+    args.dst.info_v.buffer   = rbuf;
     args.dst.info_v.datatype = dt;
     args.dst.info_v.mem_type = mem_type;
 

test/mpi/test_case.cc

@@ -124,6 +124,8 @@ std::string TestCase::str() {
     std::string _str = std::string("tc=");
     if (args.flags & UCC_COLL_ARGS_FLAG_MEM_MAPPED_BUFFERS) {
         _str += std::string("Onesided ");
+    } else if (args.mask & UCC_COLL_ARGS_FIELD_GLOBAL_WORK_BUFFER) {
+        _str += std::string("DynSeg ");
     }
 
     _str += std::string(ucc_coll_type_str(args.coll_type)) +

test/mpi/test_mpi.cc

@@ -629,10 +629,20 @@ void UccTestMpi::run_all_at_team(ucc_test_team_t &team,
                                         params.count_bits = count_bits;
                                         params.displ_bits = displ_bits;
                                         params.buffers    = onesided_bufs;
+                                        params.use_dynamic_segments = false;
 
                                         auto tcs = TestCase::init(team, c, nt, params);
                                         auto res = exec_tests(tcs, triggered, persistent);
                                         rst.insert(rst.end(), res.begin(), res.end());
+
+                                        /* Test dynamic segments for onesided alltoallv */
+                                        if ((c == UCC_COLL_TYPE_ALLTOALLV) &&
+                                            (team.ctx != ctx) && (mt == UCC_MEMORY_TYPE_HOST)) {
+                                            params.use_dynamic_segments = true;
+                                            auto tcs_dynseg = TestCase::init(team, c, nt, params);
+                                            auto res_dynseg = exec_tests(tcs_dynseg, triggered, persistent);
+                                            rst.insert(rst.end(), res_dynseg.begin(), res_dynseg.end());
+                                        }
                                     }
                                 }
                             }

test/mpi/test_mpi.h

@@ -257,6 +257,7 @@ struct TestCaseParams {
     void **buffers;
     ucc_test_vsize_flag_t count_bits;
     ucc_test_vsize_flag_t displ_bits;
+    bool use_dynamic_segments;
 };
 
 class TestCase {