misc: preparation for CSEL redesign

autogen.sh

@@ -535,7 +535,7 @@ fn_gen_binding_c() {
 
 fn_json_gen() {
     echo_n "generating json char arrays... "
-    ./maint/tuning/coll/json_gen.sh
+    ./maint/json_gen.sh
     echo "done"
 }
 

src/binding/c/comm_api.txt

@@ -300,8 +300,8 @@ MPI_Intercomm_merge:
      * The Intel test suite checks for this; it is also an easy
      * error to make */
     acthigh = high ? 1 : 0;     /* Clamp high into 1 or 0 */
-    mpi_errno = MPIR_Allreduce(MPI_IN_PLACE, &acthigh, 1, MPIR_INT_INTERNAL,
-                                MPI_SUM, intercomm_ptr->local_comm, MPIR_COLL_ATTR_SYNC);
+    mpi_errno = MPIR_Allreduce_fallback(MPI_IN_PLACE, &acthigh, 1, MPIR_INT_INTERNAL,
+                                        MPI_SUM, intercomm_ptr->local_comm, MPIR_COLL_ATTR_SYNC);
     MPIR_ERR_CHECK(mpi_errno);
     /* acthigh must either == 0 or the size of the local comm */
     if (acthigh != 0 && acthigh != intercomm_ptr->local_size) {

src/include/mpir_coll.h

@@ -11,14 +11,26 @@
 
 /* During init, not all algorithms are safe to use. For example, the csel
  * may not have been initialized. We define a set of fallback routines that
- * are safe to use during init. They are all intra algorithms.
+ * are safe to use during init.
  */
-#define MPIR_Barrier_fallback    MPIR_Barrier_intra_dissemination
-#define MPIR_Allgather_fallback  MPIR_Allgather_intra_brucks
-#define MPIR_Allgatherv_fallback MPIR_Allgatherv_intra_brucks
-#define MPIR_Allreduce_fallback  MPIR_Allreduce_intra_recursive_doubling
-#define MPIR_Bcast_fallback      MPIR_Bcast_intra_binomial
-#define MPIR_Gather_fallback     MPIR_Gather_intra_binomial
+int MPIR_Barrier_fallback(MPIR_Comm * comm_ptr, int coll_attr);
+int MPIR_Allgather_fallback(const void *sendbuf, MPI_Aint sendcount, MPI_Datatype sendtype,
+                            void *recvbuf, MPI_Aint recvcount, MPI_Datatype recvtype,
+                            MPIR_Comm * comm_ptr, int coll_attr);
+int MPIR_Allgatherv_fallback(const void *sendbuf, MPI_Aint sendcount, MPI_Datatype sendtype,
+                             void *recvbuf, const MPI_Aint * recvcounts, const MPI_Aint * displs,
+                             MPI_Datatype recvtype, MPIR_Comm * comm_ptr, int coll_attr);
+int MPIR_Allreduce_fallback(const void *sendbuf, void *recvbuf,
+                            MPI_Aint count, MPI_Datatype datatype,
+                            MPI_Op op, MPIR_Comm * comm_ptr, int coll_attr);
+int MPIR_Bcast_fallback(void *buffer, MPI_Aint count, MPI_Datatype datatype, int root,
+                        MPIR_Comm * comm_ptr, int coll_attr);
+int MPIR_Gather_fallback(const void *sendbuf, MPI_Aint sendcount, MPI_Datatype sendtype,
+                         void *recvbuf, MPI_Aint recvcount, MPI_Datatype recvtype, int root,
+                         MPIR_Comm * comm_ptr, int coll_attr);
+int MPIR_Reduce_scatter_block_fallback(const void *sendbuf, void *recvbuf, MPI_Aint recvcount,
+                                       MPI_Datatype datatype, MPI_Op op,
+                                       MPIR_Comm * comm_ptr, int coll_attr);
 
 
 /* Internal point-to-point communication for collectives */

src/mpi/coll/algorithms/treealgo/treeutil.c

@@ -758,9 +758,9 @@ int MPII_Treeutil_tree_topology_aware_k_init(MPIR_Comm * comm, int k, int root,
             } else {
                 /* rank level - build a tree on the ranks */
                 /* Do an allgather to know the current num_children on each rank */
-                mpi_errno = MPIR_Allgather_impl(&(ct->num_children), 1, MPIR_INT_INTERNAL,
-                                                num_childrens, 1, MPIR_INT_INTERNAL, comm,
-                                                MPIR_COLL_ATTR_SYNC);
+                mpi_errno = MPIR_Allgather_fallback(&(ct->num_children), 1, MPIR_INT_INTERNAL,
+                                                    num_childrens, 1, MPIR_INT_INTERNAL, comm,
+                                                    MPIR_COLL_ATTR_SYNC);
                 MPIR_ERR_CHECK(mpi_errno);
 
                 int switch_leader = tree_ut_int_elt(&level->ranks, level->root_idx);

src/mpi/coll/allgather/allgather_intra_recexch.c

@@ -106,7 +106,7 @@ int MPIR_Allgather_intra_recexch(const void *sendbuf, MPI_Aint sendcount,
         MPIR_ERR_CHECK(mpi_errno);
     }
 
-    if (step1_sendto != -1) {   /* non-participating rank sends the data to a partcipating rank */
+    if (step1_sendto != -1) {   /* non-participating rank sends the data to a participating rank */
         void *buf_to_send;
         send_offset = rank * recv_extent * recvcount;
         if (is_inplace)

src/mpi/coll/allgather/allgather_intra_smp.c

@@ -29,8 +29,9 @@ int MPIR_Allgather_intra_smp_no_order(const void *sendbuf, MPI_Aint sendcount,
     int external_rank = comm_ptr->external_rank;
 
     if (local_size == comm_size || external_size == comm_size) {
-        mpi_errno = MPIR_Allgather_impl(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype,
-                                        comm_ptr, coll_attr);
+        mpi_errno =
+            MPIR_Allgather_fallback(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype,
+                                    comm_ptr, coll_attr);
         goto fn_exit;
     }
 
@@ -80,20 +81,20 @@ int MPIR_Allgather_intra_smp_no_order(const void *sendbuf, MPI_Aint sendcount,
         MPIR_Datatype_get_extent_macro(recvtype, recvtype_extent);
         local_recvbuf = (char *) recvbuf + displs[external_rank] * recvtype_extent;
     }
-    mpi_errno = MPIR_Gather_impl(sendbuf, sendcount, sendtype,
-                                 local_recvbuf, recvcount, recvtype, 0, node_comm, coll_attr);
+    mpi_errno = MPIR_Gather_fallback(sendbuf, sendcount, sendtype,
+                                     local_recvbuf, recvcount, recvtype, 0, node_comm, coll_attr);
     MPIR_ERR_CHECK(mpi_errno);
 
     /* -- allgatherv over node roots -- */
     if (local_rank == 0) {
-        mpi_errno = MPIR_Allgatherv_impl(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL,
-                                         recvbuf, counts, displs, recvtype,
-                                         node_roots_comm, coll_attr);
+        mpi_errno = MPIR_Allgatherv_fallback(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL,
+                                             recvbuf, counts, displs, recvtype,
+                                             node_roots_comm, coll_attr);
         MPIR_ERR_CHECK(mpi_errno);
     }
 
     /* -- bcast over node -- */
-    mpi_errno = MPIR_Bcast_impl(recvbuf, total_count, recvtype, 0, node_comm, coll_attr);
+    mpi_errno = MPIR_Bcast_fallback(recvbuf, total_count, recvtype, 0, node_comm, coll_attr);
     MPIR_ERR_CHECK(mpi_errno);
 
   fn_exit:

src/mpi/coll/allgatherv/allgatherv_inter_remote_gather_local_bcast.c

@@ -71,7 +71,7 @@ int MPIR_Allgatherv_inter_remote_gather_local_bcast(const void *sendbuf, MPI_Ain
     mpi_errno = MPIR_Type_commit_impl(&newtype);
     MPIR_ERR_CHECK(mpi_errno);
 
-    mpi_errno = MPIR_Bcast_allcomm_auto(recvbuf, 1, newtype, 0, newcomm_ptr, coll_attr);
+    mpi_errno = MPIR_Bcast_fallback(recvbuf, 1, newtype, 0, newcomm_ptr, coll_attr);
     MPIR_ERR_CHECK(mpi_errno);
 
     MPIR_Type_free_impl(&newtype);

src/mpi/coll/iallgather/iallgather_tsp_recexch.c

@@ -70,7 +70,7 @@ static int MPIR_TSP_Iallgather_sched_intra_recexch_step1(int step1_sendto, int *
     int vtx_id;
     MPIR_FUNC_ENTER;
 
-    if (step1_sendto != -1) {   /* non-participating rank sends the data to a partcipating rank */
+    if (step1_sendto != -1) {   /* non-participating rank sends the data to a participating rank */
         void *buf_to_send;
         MPI_Aint send_offset = rank * recv_extent * recvcount;
         if (is_inplace)

src/mpi/coll/iallgatherv/iallgatherv_tsp_recexch.c

@@ -78,7 +78,7 @@ static int MPIR_TSP_Iallgatherv_sched_intra_recexch_step1(int step1_sendto, int
     int i, vtx_id;
     MPIR_FUNC_ENTER;
 
-    if (step1_sendto != -1) {   /* non-participating rank sends the data to a partcipating rank */
+    if (step1_sendto != -1) {   /* non-participating rank sends the data to a participating rank */
         void *buf_to_send;
         MPI_Aint send_offset = displs[rank] * recv_extent;
         if (is_inplace)

src/mpi/coll/src/Makefile.mk

@@ -9,6 +9,7 @@
 
 mpi_core_sources += \
     src/mpi/coll/src/coll_impl.c \
+    src/mpi/coll/src/coll_fallback.c \
     src/mpi/coll/src/csel.c \
     src/mpi/coll/src/csel_container.c \
     src/mpi/coll/src/csel_json_autogen.c

src/mpi/coll/src/coll_fallback.c

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) by Argonne National Laboratory
+ *     See COPYRIGHT in top-level directory
+ */
+
+#include "mpiimpl.h"
+#include "coll_impl.h"
+
+int MPIR_Barrier_fallback(MPIR_Comm * comm_ptr, int coll_attr)
+{
+    MPIR_Assert(comm_ptr->comm_kind == MPIR_COMM_KIND__INTRACOMM);
+    return MPIR_Barrier_intra_dissemination(comm_ptr, coll_attr);
+}
+
+int MPIR_Allgather_fallback(const void *sendbuf, MPI_Aint sendcount, MPI_Datatype sendtype,
+                            void *recvbuf, MPI_Aint recvcount, MPI_Datatype recvtype,
+                            MPIR_Comm * comm_ptr, int coll_attr)
+{
+    if (comm_ptr->comm_kind == MPIR_COMM_KIND__INTRACOMM) {
+        return MPIR_Allgather_intra_brucks(sendbuf, sendcount, sendtype,
+                                           recvbuf, recvcount, recvtype, comm_ptr, coll_attr);
+    } else {
+        return MPIR_Allgather_inter_local_gather_remote_bcast(sendbuf, sendcount, sendtype,
+                                                              recvbuf, recvcount, recvtype,
+                                                              comm_ptr, coll_attr);
+    }
+}
+
+int MPIR_Allgatherv_fallback(const void *sendbuf, MPI_Aint sendcount, MPI_Datatype sendtype,
+                             void *recvbuf, const MPI_Aint * recvcounts, const MPI_Aint * displs,
+                             MPI_Datatype recvtype, MPIR_Comm * comm_ptr, int coll_attr)
+{
+    MPIR_Assert(comm_ptr->comm_kind == MPIR_COMM_KIND__INTRACOMM);
+    return MPIR_Allgatherv_intra_brucks(sendbuf, sendcount, sendtype,
+                                        recvbuf, recvcounts, displs, recvtype, comm_ptr, coll_attr);
+}
+
+int MPIR_Allreduce_fallback(const void *sendbuf, void *recvbuf,
+                            MPI_Aint count, MPI_Datatype datatype,
+                            MPI_Op op, MPIR_Comm * comm_ptr, int coll_attr)
+{
+    MPIR_Assert(comm_ptr->comm_kind == MPIR_COMM_KIND__INTRACOMM);
+    return MPIR_Allreduce_intra_recursive_doubling(sendbuf, recvbuf, count, datatype, op,
+                                                   comm_ptr, coll_attr);
+}
+
+int MPIR_Bcast_fallback(void *buffer, MPI_Aint count, MPI_Datatype datatype, int root,
+                        MPIR_Comm * comm_ptr, int coll_attr)
+{
+    MPIR_Assert(comm_ptr->comm_kind == MPIR_COMM_KIND__INTRACOMM);
+    return MPIR_Bcast_intra_binomial(buffer, count, datatype, root, comm_ptr, coll_attr);
+}
+
+int MPIR_Gather_fallback(const void *sendbuf, MPI_Aint sendcount, MPI_Datatype sendtype,
+                         void *recvbuf, MPI_Aint recvcount, MPI_Datatype recvtype, int root,
+                         MPIR_Comm * comm_ptr, int coll_attr)
+{
+    MPIR_Assert(comm_ptr->comm_kind == MPIR_COMM_KIND__INTRACOMM);
+    return MPIR_Gather_intra_binomial(sendbuf, sendcount, sendtype,
+                                      recvbuf, recvcount, recvtype, root, comm_ptr, coll_attr);
+}
+
+int MPIR_Reduce_scatter_block_fallback(const void *sendbuf, void *recvbuf, MPI_Aint recvcount,
+                                       MPI_Datatype datatype, MPI_Op op,
+                                       MPIR_Comm * comm_ptr, int coll_attr)
+{
+    MPIR_Assert(comm_ptr->comm_kind == MPIR_COMM_KIND__INTRACOMM);
+    MPIR_Assert(MPIR_Op_is_commutative(op));
+    return MPIR_Reduce_scatter_block_intra_recursive_halving(sendbuf, recvbuf, recvcount, datatype,
+                                                             op, comm_ptr, coll_attr);
+}

src/mpi/comm/comm_impl.c

@@ -310,24 +310,24 @@ int MPIR_Comm_create_inter(MPIR_Comm * comm_ptr, MPIR_Group * group_ptr, MPIR_Co
         MPIR_ERR_CHECK(mpi_errno);
 
         /* Broadcast to the other members of the local group */
-        mpi_errno = MPIR_Bcast(rinfo, 2, MPIR_INT_INTERNAL, 0, comm_ptr->local_comm,
-                               MPIR_COLL_ATTR_SYNC);
+        mpi_errno = MPIR_Bcast_fallback(rinfo, 2, MPIR_INT_INTERNAL, 0, comm_ptr->local_comm,
+                                        MPIR_COLL_ATTR_SYNC);
         MPIR_ERR_CHECK(mpi_errno);
-        mpi_errno = MPIR_Bcast(remote_mapping, remote_size, MPIR_INT_INTERNAL, 0,
-                               comm_ptr->local_comm, MPIR_COLL_ATTR_SYNC);
+        mpi_errno = MPIR_Bcast_fallback(remote_mapping, remote_size, MPIR_INT_INTERNAL, 0,
+                                        comm_ptr->local_comm, MPIR_COLL_ATTR_SYNC);
         MPIR_ERR_CHECK(mpi_errno);
     } else {
         /* The other processes */
         /* Broadcast to the other members of the local group */
-        mpi_errno = MPIR_Bcast(rinfo, 2, MPIR_INT_INTERNAL, 0, comm_ptr->local_comm,
-                               MPIR_COLL_ATTR_SYNC);
+        mpi_errno = MPIR_Bcast_fallback(rinfo, 2, MPIR_INT_INTERNAL, 0, comm_ptr->local_comm,
+                                        MPIR_COLL_ATTR_SYNC);
         MPIR_ERR_CHECK(mpi_errno);
 
         context_id = rinfo[0];
         remote_size = rinfo[1];
         MPIR_CHKLMEM_MALLOC(remote_mapping, remote_size * sizeof(int));
-        mpi_errno = MPIR_Bcast(remote_mapping, remote_size, MPIR_INT_INTERNAL, 0,
-                               comm_ptr->local_comm, MPIR_COLL_ATTR_SYNC);
+        mpi_errno = MPIR_Bcast_fallback(remote_mapping, remote_size, MPIR_INT_INTERNAL, 0,
+                                        comm_ptr->local_comm, MPIR_COLL_ATTR_SYNC);
         MPIR_ERR_CHECK(mpi_errno);
     }
 
@@ -690,8 +690,8 @@ int MPIR_Intercomm_create_from_groups_impl(MPIR_Group * local_group_ptr, int loc
 
     /* synchronize mpi_errno */
     int tmp_err = mpi_errno;
-    mpi_errno = MPIR_Bcast_impl(&tmp_err, 1, MPIR_INT_INTERNAL, local_leader, local_comm,
-                                MPIR_COLL_ATTR_SYNC);
+    mpi_errno = MPIR_Bcast_fallback(&tmp_err, 1, MPIR_INT_INTERNAL, local_leader, local_comm,
+                                    MPIR_COLL_ATTR_SYNC);
     MPIR_ERR_CHECK(mpi_errno);
     mpi_errno = tmp_err;
     MPIR_ERR_CHECK(mpi_errno);
@@ -1050,8 +1050,8 @@ int MPIR_Intercomm_merge_impl(MPIR_Comm * comm_ptr, int high, MPIR_Comm ** new_i
      * value of local_high, which may have changed if both groups
      * of processes had the same value for high
      */
-    mpi_errno = MPIR_Bcast(&local_high, 1, MPIR_INT_INTERNAL, 0, comm_ptr->local_comm,
-                           MPIR_COLL_ATTR_SYNC);
+    mpi_errno = MPIR_Bcast_fallback(&local_high, 1, MPIR_INT_INTERNAL, 0, comm_ptr->local_comm,
+                                    MPIR_COLL_ATTR_SYNC);
     MPIR_ERR_CHECK(mpi_errno);
 
     /*

src/mpi/comm/comm_split.c

@@ -111,8 +111,9 @@ int MPIR_Comm_split_impl(MPIR_Comm * comm_ptr, int color, int key, MPIR_Comm **
         local_comm_ptr = comm_ptr;
     }
     /* Gather information on the local group of processes */
-    mpi_errno = MPIR_Allgather(MPI_IN_PLACE, 2, MPIR_INT_INTERNAL, table, 2, MPIR_INT_INTERNAL,
-                               local_comm_ptr, MPIR_COLL_ATTR_SYNC);
+    mpi_errno = MPIR_Allgather_fallback(MPI_IN_PLACE, 2, MPIR_INT_INTERNAL,
+                                        table, 2, MPIR_INT_INTERNAL,
+                                        local_comm_ptr, MPIR_COLL_ATTR_SYNC);
     MPIR_ERR_CHECK(mpi_errno);
 
     /* Step 2: How many processes have our same color? */
@@ -156,8 +157,9 @@ int MPIR_Comm_split_impl(MPIR_Comm * comm_ptr, int color, int key, MPIR_Comm **
          * same color */
         mypair.color = color;
         mypair.key = key;
-        mpi_errno = MPIR_Allgather(&mypair, 2, MPIR_INT_INTERNAL, remotetable, 2, MPIR_INT_INTERNAL,
-                                   comm_ptr, MPIR_COLL_ATTR_SYNC);
+        mpi_errno = MPIR_Allgather_fallback(&mypair, 2, MPIR_INT_INTERNAL,
+                                            remotetable, 2, MPIR_INT_INTERNAL,
+                                            comm_ptr, MPIR_COLL_ATTR_SYNC);
         MPIR_ERR_CHECK(mpi_errno);
 
         /* Each process can now match its color with the entries in the table */
@@ -214,19 +216,17 @@ int MPIR_Comm_split_impl(MPIR_Comm * comm_ptr, int color, int key, MPIR_Comm **
                                       &remote_context_id, 1, MPIR_CONTEXT_ID_T_DATATYPE,
                                       0, 0, comm_ptr, MPI_STATUS_IGNORE, MPIR_COLL_ATTR_SYNC);
             MPIR_ERR_CHECK(mpi_errno);
-            mpi_errno =
-                MPIR_Bcast(&remote_context_id, 1, MPIR_CONTEXT_ID_T_DATATYPE, 0, local_comm_ptr,
-                           MPIR_COLL_ATTR_SYNC);
+            mpi_errno = MPIR_Bcast_fallback(&remote_context_id, 1, MPIR_CONTEXT_ID_T_DATATYPE, 0,
+                                            local_comm_ptr, MPIR_COLL_ATTR_SYNC);
             MPIR_ERR_CHECK(mpi_errno);
 
             if (!in_newcomm) {
                 MPIR_Free_contextid(new_context_id);
             }
         } else {
             /* Broadcast to the other members of the local group */
-            mpi_errno =
-                MPIR_Bcast(&remote_context_id, 1, MPIR_CONTEXT_ID_T_DATATYPE, 0, local_comm_ptr,
-                           MPIR_COLL_ATTR_SYNC);
+            mpi_errno = MPIR_Bcast_fallback(&remote_context_id, 1, MPIR_CONTEXT_ID_T_DATATYPE, 0,
+                                            local_comm_ptr, MPIR_COLL_ATTR_SYNC);
             MPIR_ERR_CHECK(mpi_errno);
         }
     }

src/mpi/comm/comm_split_type_nbhd.c

@@ -275,8 +275,9 @@ static int network_split_by_minsize(MPIR_Comm * comm_ptr, int key, int subcomm_m
         }
         MPIR_Assert(num_processes_at_node != NULL);
         /* Send the count to processes */
-        mpi_errno = MPIR_Allreduce(MPI_IN_PLACE, num_processes_at_node, num_nodes,
-                                   MPIR_INT_INTERNAL, MPI_SUM, comm_ptr, MPIR_COLL_ATTR_SYNC);
+        mpi_errno = MPIR_Allreduce_fallback(MPI_IN_PLACE, num_processes_at_node, num_nodes,
+                                            MPIR_INT_INTERNAL, MPI_SUM, comm_ptr,
+                                            MPIR_COLL_ATTR_SYNC);
 
         if (topo_type == MPIR_NETTOPO_TYPE__FAT_TREE ||
             topo_type == MPIR_NETTOPO_TYPE__CLOS_NETWORK) {
@@ -375,8 +376,8 @@ static int network_split_by_minsize(MPIR_Comm * comm_ptr, int key, int subcomm_m
             tree_depth = MPIR_hwtopo_get_depth(obj_containing_cpuset);
 
             /* get min tree depth to all processes */
-            MPIR_Allreduce(&tree_depth, &min_tree_depth, 1, MPIR_INT_INTERNAL, MPI_MIN, node_comm,
-                           MPIR_COLL_ATTR_SYNC);
+            MPIR_Allreduce_fallback(&tree_depth, &min_tree_depth, 1, MPIR_INT_INTERNAL, MPI_MIN,
+                                    node_comm, MPIR_COLL_ATTR_SYNC);
 
             if (min_tree_depth) {
                 int num_hwloc_objs_at_depth;
@@ -389,8 +390,8 @@ static int network_split_by_minsize(MPIR_Comm * comm_ptr, int key, int subcomm_m
                 parent_idx[subcomm_rank] = obj_containing_cpuset;
 
                 /* get parent_idx to all processes */
-                MPIR_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, parent_idx, 1, MPIR_INT_INTERNAL,
-                               node_comm, MPIR_COLL_ATTR_SYNC);
+                MPIR_Allgather_fallback(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, parent_idx, 1,
+                                        MPIR_INT_INTERNAL, node_comm, MPIR_COLL_ATTR_SYNC);
 
                 /* reorder parent indices */
                 for (i = 0; i < num_procs - 1; i++) {

src/mpi/comm/commutil.c

@@ -780,8 +780,7 @@ static int init_comm_seq(MPIR_Comm * comm)
         /* Every rank need share the same seq from root. NOTE: it is possible for
          * different communicators to have the same seq. It is only used as an
          * opportunistic optimization */
-        mpi_errno = MPIR_Bcast_allcomm_auto(&tmp, 1, MPIR_INT_INTERNAL, 0, comm,
-                                            MPIR_COLL_ATTR_SYNC);
+        mpi_errno = MPIR_Bcast_fallback(&tmp, 1, MPIR_INT_INTERNAL, 0, comm, MPIR_COLL_ATTR_SYNC);
         MPIR_ERR_CHECK(mpi_errno);
 
         comm->seq = tmp;