From e2f28158072c0efcab82ece66dd3e73f5fc3bebe Mon Sep 17 00:00:00 2001 From: Yanfei Guo Date: Thu, 10 Jul 2025 22:54:52 -0500 Subject: [PATCH 1/6] csel: improve printing of collective selection logic Creating CSEL constants array for the string name of collective and comm hierarchy. These string values will be used during parsing of the JSON file, and printing of the CSEL tree node. Separating the implementation details CSEL tree printing function for the ease of maintenance. --- src/include/mpir_csel.h | 8 + src/mpi/coll/src/Makefile.mk | 2 + src/mpi/coll/src/csel.c | 390 +++----------------------- src/mpi/coll/src/csel_constants.c | 451 ++++++++++++++++++++++++++++++ src/mpi/coll/src/csel_internal.h | 155 ++++++++++ src/mpi/coll/src/csel_print.c | 220 +++++++++++++++ 6 files changed, 877 insertions(+), 349 deletions(-) create mode 100644 src/mpi/coll/src/csel_constants.c create mode 100644 src/mpi/coll/src/csel_internal.h create mode 100644 src/mpi/coll/src/csel_print.c diff --git a/src/include/mpir_csel.h b/src/include/mpir_csel.h index 07f061e98ef..5bf3cc25e35 100644 --- a/src/include/mpir_csel.h +++ b/src/include/mpir_csel.h @@ -57,6 +57,14 @@ typedef enum { MPIR_CSEL_COLL_TYPE__END, } MPIR_Csel_coll_type_e; +typedef enum { + MPIR_CSEL_COMM_HIERARCHY__FLAT = 0, + MPIR_CSEL_COMM_HIERARCHY__NODE, + MPIR_CSEL_COMM_HIERARCHY__NODE_ROOTS, + MPIR_CSEL_COMM_HIERARCHY__PARENT, + MPIR_CSEL_COMM_HIERARCHY__END, +} MPIR_Csel_comm_hierarchy_e; + typedef struct { MPIR_Csel_coll_type_e coll_type; MPIR_Comm *comm_ptr; diff --git a/src/mpi/coll/src/Makefile.mk b/src/mpi/coll/src/Makefile.mk index 1dd1b78b204..607e8ec278e 100644 --- a/src/mpi/coll/src/Makefile.mk +++ b/src/mpi/coll/src/Makefile.mk @@ -10,5 +10,7 @@ mpi_core_sources += \ src/mpi/coll/src/coll_impl.c \ src/mpi/coll/src/csel.c \ + src/mpi/coll/src/csel_print.c \ + src/mpi/coll/src/csel_constants.c \ src/mpi/coll/src/csel_container.c \ src/mpi/coll/src/csel_json_autogen.c diff --git a/src/mpi/coll/src/csel.c b/src/mpi/coll/src/csel.c index b2712350764..eb58e599ebb 100644 --- a/src/mpi/coll/src/csel.c +++ b/src/mpi/coll/src/csel.c @@ -6,256 +6,12 @@ #include "mpiimpl.h" #include "mpl.h" #include "mpir_csel.h" +#include "csel_internal.h" #include /* open */ #include /* mmap */ #include #include -typedef enum { - /* global operator types */ - CSEL_NODE_TYPE__OPERATOR__IS_MULTI_THREADED = 0, - - /* comm-specific operator types */ - CSEL_NODE_TYPE__OPERATOR__COMM_TYPE_INTRA, - CSEL_NODE_TYPE__OPERATOR__COMM_TYPE_INTER, - - CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_LE, - CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_LT, - CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_NODE_COMM_SIZE, - CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_POW2, - - CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY, - CSEL_NODE_TYPE__OPERATOR__IS_NODE_CONSECUTIVE, - - CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LE, - CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LT, - - /* collective selection operator */ - CSEL_NODE_TYPE__OPERATOR__COLLECTIVE, - - /* message-specific operator types */ - CSEL_NODE_TYPE__OPERATOR__AVG_MSG_SIZE_LE, - CSEL_NODE_TYPE__OPERATOR__AVG_MSG_SIZE_LT, - CSEL_NODE_TYPE__OPERATOR__TOTAL_MSG_SIZE_LE, - CSEL_NODE_TYPE__OPERATOR__TOTAL_MSG_SIZE_LT, - - CSEL_NODE_TYPE__OPERATOR__COUNT_LE, - CSEL_NODE_TYPE__OPERATOR__COUNT_LT_POW2, - - CSEL_NODE_TYPE__OPERATOR__IS_SBUF_INPLACE, - CSEL_NODE_TYPE__OPERATOR__IS_BLOCK_REGULAR, - CSEL_NODE_TYPE__OPERATOR__IS_COMMUTATIVE, - CSEL_NODE_TYPE__OPERATOR__IS_OP_BUILT_IN, - - /* any - has to be the last branch in an array */ - CSEL_NODE_TYPE__OPERATOR__ANY, - - /* container type */ - CSEL_NODE_TYPE__CONTAINER, -} csel_node_type_e; - -typedef struct csel_node { - csel_node_type_e type; - - union { - /* global types */ - struct { - int val; - } is_multi_threaded; - - /* comm-specific operator types */ - struct { - int val; - } comm_size_le; - struct { - int val; - } comm_size_lt; - - /* collective selection operator */ - struct { - MPIR_Csel_coll_type_e coll_type; - } collective; - - /* message-specific operator types */ - struct { - int val; - } avg_msg_size_le; - struct { - int val; - } avg_msg_size_lt; - struct { - int val; - } total_msg_size_le; - struct { - int val; - } total_msg_size_lt; - struct { - int val; - } count_le; - struct { - bool val; - } is_commutative; - struct { - bool val; - } is_sbuf_inplace; - struct { - bool val; - } is_op_built_in; - struct { - bool val; - } is_block_regular; - struct { - bool val; - } is_node_consecutive; - struct { - int val; - } comm_avg_ppn_le; - struct { - int val; - } comm_avg_ppn_lt; - struct { - bool val; - } comm_hierarchy; - struct { - void *container; - } cnt; - } u; - - struct csel_node *success; - struct csel_node *failure; -} csel_node_s; - -typedef enum { - CSEL_TYPE__ROOT, - CSEL_TYPE__PRUNED, -} csel_type_e; - -typedef struct { - csel_type_e type; - - union { - struct { - csel_node_s *tree; - } root; - struct { - /* one tree for each collective */ - csel_node_s *coll_trees[MPIR_CSEL_COLL_TYPE__END]; - } pruned; - } u; -} csel_s; - -static int nesting = -1; -#define nprintf(...) \ - do { \ - for (int i = 0; i < nesting; i++) \ - printf(" "); \ - printf(__VA_ARGS__); \ - } while (0) - -static void print_tree(csel_node_s * node) ATTRIBUTE((unused)); -static void print_tree(csel_node_s * node) -{ - nesting++; - - if (node == NULL) - return; - - switch (node->type) { - case CSEL_NODE_TYPE__OPERATOR__IS_MULTI_THREADED: - nprintf("MPI library is multithreaded\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_TYPE_INTRA: - nprintf("comm_type is intra\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_TYPE_INTER: - nprintf("comm_type is inter\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__COLLECTIVE: - nprintf("collective: %d\n", node->u.collective.coll_type); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_LE: - nprintf("comm_size <= %d\n", node->u.comm_size_le.val); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_LT: - nprintf("comm_size < %d\n", node->u.comm_size_lt.val); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_POW2: - nprintf("comm_size is power-of-two\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_NODE_COMM_SIZE: - nprintf("comm_size is the same as node_comm_size\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__AVG_MSG_SIZE_LE: - nprintf("avg_msg_size <= %d\n", node->u.avg_msg_size_le.val); - break; - case CSEL_NODE_TYPE__OPERATOR__AVG_MSG_SIZE_LT: - nprintf("avg_msg_size < %d\n", node->u.avg_msg_size_lt.val); - break; - case CSEL_NODE_TYPE__OPERATOR__TOTAL_MSG_SIZE_LE: - nprintf("total_msg_size <= %d\n", node->u.total_msg_size_le.val); - break; - case CSEL_NODE_TYPE__OPERATOR__TOTAL_MSG_SIZE_LT: - nprintf("total_msg_size < %d\n", node->u.total_msg_size_lt.val); - break; - case CSEL_NODE_TYPE__CONTAINER: - nprintf("container\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__COUNT_LE: - nprintf("count <= %d\n", node->u.count_le.val); - break; - case CSEL_NODE_TYPE__OPERATOR__COUNT_LT_POW2: - nprintf("count < nearest power-of-two less than comm size\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__IS_SBUF_INPLACE: - nprintf("source buffer is MPI_IN_PLACE\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__IS_BLOCK_REGULAR: - nprintf("all blocks have the same count\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY: - if (node->u.comm_hierarchy.val) - nprintf("communicator has hierarchical structure\n"); - else - nprintf("communicator does not have hierarchical structure\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__IS_NODE_CONSECUTIVE: - nprintf("process ranks are consecutive on the node\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LE: - nprintf("communicator's avg ppn <= %d\n", node->u.comm_avg_ppn_le.val); - break; - case CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LT: - nprintf("communicator's avg ppn < %d\n", node->u.comm_avg_ppn_lt.val); - break; - case CSEL_NODE_TYPE__OPERATOR__IS_COMMUTATIVE: - if (node->u.is_commutative.val == true) - nprintf("operation is commutative\n"); - else - nprintf("operation is not commutative\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__IS_OP_BUILT_IN: - nprintf("other operators\n"); - break; - case CSEL_NODE_TYPE__OPERATOR__ANY: - nprintf("any\n"); - break; - default: - nprintf("unknown operator\n"); - MPIR_Assert(0); - } - - if (node->type != CSEL_NODE_TYPE__CONTAINER) { - print_tree(node->success); - if (node->failure) { - nesting--; - print_tree(node->failure); - nesting++; - } - } - - nesting--; -} - static void validate_tree(csel_node_s * node) { static int coll = -1; @@ -350,7 +106,10 @@ static csel_node_s *parse_json_tree(struct json_object *obj, prevnode->failure = tmp; prevnode = tmp; - if (!strcmp(ckey, "is_multi_threaded=yes")) { + /* =any condition must be checked first */ + if (key_is_any(ckey)) { + tmp->type = CSEL_NODE_TYPE__OPERATOR__ANY; + } else if (!strcmp(ckey, "is_multi_threaded=yes")) { tmp->type = CSEL_NODE_TYPE__OPERATOR__IS_MULTI_THREADED; tmp->u.is_multi_threaded.val = true; } else if (!strcmp(ckey, "is_multi_threaded=no")) { @@ -364,95 +123,16 @@ static csel_node_s *parse_json_tree(struct json_object *obj, tmp->type = CSEL_NODE_TYPE__OPERATOR__COLLECTIVE; char *str = ckey + strlen("collective="); - if (!strcmp(str, "allgather")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ALLGATHER; - else if (!strcmp(str, "allgatherv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ALLGATHERV; - else if (!strcmp(str, "allreduce")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ALLREDUCE; - else if (!strcmp(str, "alltoall")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ALLTOALL; - else if (!strcmp(str, "alltoallv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ALLTOALLV; - else if (!strcmp(str, "alltoallw")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ALLTOALLW; - else if (!strcmp(str, "barrier")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__BARRIER; - else if (!strcmp(str, "bcast")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__BCAST; - else if (!strcmp(str, "exscan")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__EXSCAN; - else if (!strcmp(str, "gather")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__GATHER; - else if (!strcmp(str, "gatherv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__GATHERV; - else if (!strcmp(str, "iallgather")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IALLGATHER; - else if (!strcmp(str, "iallgatherv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IALLGATHERV; - else if (!strcmp(str, "iallreduce")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IALLREDUCE; - else if (!strcmp(str, "ialltoall")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IALLTOALL; - else if (!strcmp(str, "ialltoallv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IALLTOALLV; - else if (!strcmp(str, "ialltoallw")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IALLTOALLW; - else if (!strcmp(str, "ibarrier")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IBARRIER; - else if (!strcmp(str, "ibcast")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IBCAST; - else if (!strcmp(str, "iexscan")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IEXSCAN; - else if (!strcmp(str, "igather")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IGATHER; - else if (!strcmp(str, "igatherv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IGATHERV; - else if (!strcmp(str, "ineighbor_allgather")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLGATHER; - else if (!strcmp(str, "ineighbor_allgatherv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLGATHERV; - else if (!strcmp(str, "ineighbor_alltoall")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLTOALL; - else if (!strcmp(str, "ineighbor_alltoallv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLTOALLV; - else if (!strcmp(str, "ineighbor_alltoallw")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLTOALLW; - else if (!strcmp(str, "ireduce")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IREDUCE; - else if (!strcmp(str, "ireduce_scatter")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IREDUCE_SCATTER; - else if (!strcmp(str, "ireduce_scatter_block")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__IREDUCE_SCATTER_BLOCK; - else if (!strcmp(str, "iscan")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ISCAN; - else if (!strcmp(str, "iscatter")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ISCATTER; - else if (!strcmp(str, "iscatterv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__ISCATTERV; - else if (!strcmp(str, "neighbor_allgather")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLGATHER; - else if (!strcmp(str, "neighbor_allgatherv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLGATHERV; - else if (!strcmp(str, "neighbor_alltoall")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLTOALL; - else if (!strcmp(str, "neighbor_alltoallv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLTOALLV; - else if (!strcmp(str, "neighbor_alltoallw")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLTOALLW; - else if (!strcmp(str, "reduce")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__REDUCE; - else if (!strcmp(str, "reduce_scatter")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__REDUCE_SCATTER; - else if (!strcmp(str, "reduce_scatter_block")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__REDUCE_SCATTER_BLOCK; - else if (!strcmp(str, "scan")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__SCAN; - else if (!strcmp(str, "scatter")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__SCATTER; - else if (!strcmp(str, "scatterv")) - tmp->u.collective.coll_type = MPIR_CSEL_COLL_TYPE__SCATTERV; - else { + + bool matched = false; + for (int idx = 0; idx < MPIR_CSEL_COLL_TYPE__END; idx++) { + if (strcmp(str, Csel_coll_type_str[idx]) == 0) { + tmp->u.collective.coll_type = idx; + matched = true; + break; + } + } + if (!matched) { MPIR_Assert(0); } } else if (!strcmp(ckey, "comm_size=pow2")) { @@ -518,20 +198,17 @@ static csel_node_s *parse_json_tree(struct json_object *obj, } else if (!strncmp(ckey, "comm_avg_ppn<", strlen("comm_avg_ppn<"))) { tmp->type = CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LT; tmp->u.comm_avg_ppn_le.val = atoi(ckey + strlen("comm_avg_ppn<")); - } else if (!strcmp(ckey, "comm_hierarchy=parent")) { + } else if (!strncmp(ckey, "comm_hierarchy=", strlen("comm_hierarchy="))) { tmp->type = CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY; - tmp->u.comm_hierarchy.val = true; - } else if (!strcmp(ckey, "comm_hierarchy=node_roots")) { - tmp->type = CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY; - tmp->u.comm_hierarchy.val = false; - } else if (!strcmp(ckey, "comm_hierarchy=node")) { - tmp->type = CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY; - tmp->u.comm_hierarchy.val = false; - } else if (!strcmp(ckey, "comm_hierarchy=flat")) { - tmp->type = CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY; - tmp->u.comm_hierarchy.val = false; - } else if (key_is_any(ckey)) { - tmp->type = CSEL_NODE_TYPE__OPERATOR__ANY; + + char *str = ckey + strlen("comm_hierarchy="); + + for (int idx = 0; idx < MPIR_CSEL_COMM_HIERARCHY__END; idx++) { + if (strcmp(str, Csel_comm_hierarchy_str[idx]) == 0) { + tmp->u.comm_hierarchy.val = idx; + break; + } + } } else { fprintf(stderr, "unknown key %s\n", key); fflush(stderr); @@ -562,6 +239,16 @@ int MPIR_Csel_create_from_buf(const char *json, json_object_put(tree); + if (MPIR_CVAR_DEBUG_SUMMARY && MPIR_Process.rank == 0) { + printf("====================================\n"); + printf("Processed Collective Selection Tree:\n"); + Csel_print_tree(csel->u.root.tree); + printf("==========================================\n"); + printf("Summary of rules per collective algorithm:\n"); + Csel_print_rules(csel->u.root.tree); + + } + fn_exit: *csel_ = csel; return 0; @@ -583,6 +270,10 @@ int MPIR_Csel_create_from_file(const char *json_file, char *json = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); close(fd); + if (MPIR_CVAR_DEBUG_SUMMARY && MPIR_Process.rank == 0) { + printf("Loaded Collective Selection Tree from %s:\n", json_file); + } + MPIR_Csel_create_from_buf(json, create_container, csel_); fn_fail: @@ -638,7 +329,8 @@ static csel_node_s *prune_tree(csel_node_s * root, MPIR_Comm * comm_ptr) break; case CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY: - if (MPIR_Comm_is_parent_comm(comm_ptr) == node->u.comm_hierarchy.val) + if (MPIR_Comm_is_parent_comm(comm_ptr) + && (node->u.comm_hierarchy.val == MPIR_CSEL_COMM_HIERARCHY__PARENT)) node = node->success; else node = node->failure; diff --git a/src/mpi/coll/src/csel_constants.c b/src/mpi/coll/src/csel_constants.c new file mode 100644 index 00000000000..ddf81022a29 --- /dev/null +++ b/src/mpi/coll/src/csel_constants.c @@ -0,0 +1,451 @@ +/* + * Copyright (C) by Argonne National Laboratory + * See COPYRIGHT in top-level directory + */ + +/* TODO: this file should be generated */ + +#include "csel_internal.h" + +const char *Csel_coll_type_str[] = { + /* MPIR_CSEL_COLL_TYPE__ALLGATHER */ "allgather", + /* MPIR_CSEL_COLL_TYPE__ALLGATHERV */ "allgatherv", + /* MPIR_CSEL_COLL_TYPE__ALLREDUCE */ "allreduce", + /* MPIR_CSEL_COLL_TYPE__ALLTOALL */ "alltoall", + /* MPIR_CSEL_COLL_TYPE__ALLTOALLV */ "alltoallv", + /* MPIR_CSEL_COLL_TYPE__ALLTOALLW */ "alltoallw", + /* MPIR_CSEL_COLL_TYPE__BARRIER */ "barrier", + /* MPIR_CSEL_COLL_TYPE__BCAST */ "bcast", + /* MPIR_CSEL_COLL_TYPE__EXSCAN */ "exscan", + /* MPIR_CSEL_COLL_TYPE__GATHER */ "gather", + /* MPIR_CSEL_COLL_TYPE__GATHERV */ "gatherv", + /* MPIR_CSEL_COLL_TYPE__IALLGATHER */ "iallgather", + /* MPIR_CSEL_COLL_TYPE__IALLGATHERV */ "iallgatherv", + /* MPIR_CSEL_COLL_TYPE__IALLREDUCE */ "iallreduce", + /* MPIR_CSEL_COLL_TYPE__IALLTOALL */ "ialltoall", + /* MPIR_CSEL_COLL_TYPE__IALLTOALLV */ "ialltoallv", + /* MPIR_CSEL_COLL_TYPE__IALLTOALLW */ "ialltoallw", + /* MPIR_CSEL_COLL_TYPE__IBARRIER */ "ibarrier", + /* MPIR_CSEL_COLL_TYPE__IBCAST */ "ibcast", + /* MPIR_CSEL_COLL_TYPE__IEXSCAN */ "iexscan", + /* MPIR_CSEL_COLL_TYPE__IGATHER */ "igather", + /* MPIR_CSEL_COLL_TYPE__IGATHERV */ "igatherv", + /* MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLGATHER */ "ineighbor_allgather", + /* MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLGATHERV */ "ineighbor_allgatherv", + /* MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLTOALL */ "ineighbor_alltoall", + /* MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLTOALLV */ "ineighbor_alltoallv", + /* MPIR_CSEL_COLL_TYPE__INEIGHBOR_ALLTOALLW */ "ineighbor_alltoallw", + /* MPIR_CSEL_COLL_TYPE__IREDUCE */ "ireduce", + /* MPIR_CSEL_COLL_TYPE__IREDUCE_SCATTER */ "ireduce_scatter", + /* MPIR_CSEL_COLL_TYPE__IREDUCE_SCATTER_BLOCK */ "ireduce_scatter_block", + /* MPIR_CSEL_COLL_TYPE__ISCAN */ "iscan", + /* MPIR_CSEL_COLL_TYPE__ISCATTER */ "iscatter", + /* MPIR_CSEL_COLL_TYPE__ISCATTERV */ "iscatterv", + /* MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLGATHER */ "neighbor_allgather", + /* MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLGATHERV */ "neighbor_allgatherv", + /* MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLTOALL */ "neighbor_alltoall", + /* MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLTOALLV */ "neighbor_alltoallv", + /* MPIR_CSEL_COLL_TYPE__NEIGHBOR_ALLTOALLW */ "neighbor_alltoallw", + /* MPIR_CSEL_COLL_TYPE__REDUCE */ "reduce", + /* MPIR_CSEL_COLL_TYPE__REDUCE_SCATTER */ "reduce_scatter", + /* MPIR_CSEL_COLL_TYPE__REDUCE_SCATTER_BLOCK */ "reduce_scatter_block", + /* MPIR_CSEL_COLL_TYPE__SCAN */ "scan", + /* MPIR_CSEL_COLL_TYPE__SCATTER */ "scatter", + /* MPIR_CSEL_COLL_TYPE__SCATTERV */ "scatterv", + /* MPIR_CSEL_COLL_TYPE__END */ "!END_OF_COLLECTIVE" +}; + +const char *Csel_comm_hierarchy_str[] = { + /* MPIR_CSEL_COMM_HIERARCHY__FLAT */ "flat", + /* MPIR_CSEL_COMM_HIERARCHY__NODE */ "node", + /* MPIR_CSEL_COMM_HIERARCHY__NODE_ROOTS */ "node_roots", + /* MPIR_CSEL_COMM_HIERARCHY__PARENT */ "parent", + /* MPIR_CSEL_COMM_HIERARCHY__END */ "!END_OF_COMM_HIERARCHY" +}; + +const char *Csel_container_type_str[] = { + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_brucks */ + "MPIR_Allgather_intra_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_k_brucks */ + "MPIR_Allgather_intra_k_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recursive_doubling */ + "MPIR_Allgather_intra_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_ring */ + "MPIR_Allgather_intra_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recexch_doubling */ + "MPIR_Allgather_intra_recexch_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recexch_halving */ + "MPIR_Allgather_intra_recexch_halving", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_inter_local_gather_remote_bcast */ + "MPIR_Allgather_inter_local_gather_remote_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_allcomm_nb */ + "MPIR_Allgather_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_brucks */ + "MPIR_Allgatherv_intra_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_recursive_doubling */ + "MPIR_Allgatherv_intra_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_ring */ + "MPIR_Allgatherv_intra_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_inter_remote_gather_local_bcast */ + "MPIR_Allgatherv_inter_remote_gather_local_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_allcomm_nb */ + "MPIR_Allgatherv_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recursive_doubling */ + "MPIR_Allreduce_intra_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recursive_multiplying */ + "MPIR_Allreduce_intra_recursive_multiplying", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_reduce_scatter_allgather */ + "MPIR_Allreduce_intra_reduce_scatter_allgather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_smp */ "MPIR_Allreduce_intra_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_tree */ + "MPIR_Allreduce_intra_tree", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recexch */ + "MPIR_Allreduce_intra_recexch", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_ring */ + "MPIR_Allreduce_intra_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_k_reduce_scatter_allgather */ + "MPIR_Allreduce_intra_k_reduce_scatter_allgather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_ccl */ "MPIR_Allreduce_intra_ccl", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_inter_reduce_exchange_bcast */ + "MPIR_Allreduce_inter_reduce_exchange_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_allcomm_nb */ + "MPIR_Allreduce_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_brucks */ + "MPIR_Alltoall_intra_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_k_brucks */ + "MPIR_Alltoall_intra_k_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_pairwise */ + "MPIR_Alltoall_intra_pairwise", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_pairwise_sendrecv_replace */ + "MPIR_Alltoall_intra_pairwise_sendrecv_replace", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_scattered */ + "MPIR_Alltoall_intra_scattered", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_inter_pairwise_exchange */ + "MPIR_Alltoall_inter_pairwise_exchange", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_allcomm_nb */ "MPIR_Alltoall_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_intra_pairwise_sendrecv_replace */ + "MPIR_Alltoallv_intra_pairwise_sendrecv_replace", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_intra_scattered */ + "MPIR_Alltoallv_intra_scattered", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_inter_pairwise_exchange */ + "MPIR_Alltoallv_inter_pairwise_exchange", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_allcomm_nb */ + "MPIR_Alltoallv_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_intra_pairwise_sendrecv_replace */ + "MPIR_Alltoallw_intra_pairwise_sendrecv_replace", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_intra_scattered */ + "MPIR_Alltoallw_intra_scattered", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_inter_pairwise_exchange */ + "MPIR_Alltoallw_inter_pairwise_exchange", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_allcomm_nb */ + "MPIR_Alltoallw_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_k_dissemination */ + "MPIR_Barrier_intra_k_dissemination", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_recexch */ + "MPIR_Barrier_intra_recexch", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_smp */ "MPIR_Barrier_intra_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_inter_bcast */ "MPIR_Barrier_inter_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_allcomm_nb */ "MPIR_Barrier_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_binomial */ + "MPIR_Bcast_intra_binomial", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_scatter_recursive_doubling_allgather */ + "MPIR_Bcast_intra_scatter_recursive_doubling_allgather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_scatter_ring_allgather */ + "MPIR_Bcast_intra_scatter_ring_allgather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_smp */ "MPIR_Bcast_intra_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_tree */ "MPIR_Bcast_intra_tree", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_pipelined_tree */ + "MPIR_Bcast_intra_pipelined_tree", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_inter_remote_send_local_bcast */ + "MPIR_Bcast_inter_remote_send_local_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_allcomm_nb */ "MPIR_Bcast_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Exscan_intra_recursive_doubling */ + "MPIR_Exscan_intra_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Exscan_allcomm_nb */ "MPIR_Exscan_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_intra_binomial */ + "MPIR_Gather_intra_binomial", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_inter_linear */ "MPIR_Gather_inter_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_inter_local_gather_remote_send */ + "MPIR_Gather_inter_local_gather_remote_send", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_allcomm_nb */ "MPIR_Gather_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gatherv_allcomm_linear */ + "MPIR_Gatherv_allcomm_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gatherv_allcomm_nb */ "MPIR_Gatherv_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_brucks */ + "MPIR_Iallgather_intra_tsp_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_brucks */ + "MPIR_Iallgather_intra_sched_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_recursive_doubling */ + "MPIR_Iallgather_intra_sched_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_ring */ + "MPIR_Iallgather_intra_sched_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_recexch_doubling */ + "MPIR_Iallgather_intra_tsp_recexch_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_recexch_halving */ + "MPIR_Iallgather_intra_tsp_recexch_halving", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_ring */ + "MPIR_Iallgather_intra_tsp_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_inter_sched_local_gather_remote_bcast */ + "MPIR_Iallgather_inter_sched_local_gather_remote_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_brucks */ + "MPIR_Iallgatherv_intra_tsp_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_brucks */ + "MPIR_Iallgatherv_intra_sched_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_recursive_doubling */ + "MPIR_Iallgatherv_intra_sched_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_ring */ + "MPIR_Iallgatherv_intra_sched_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_recexch_doubling */ + "MPIR_Iallgatherv_intra_tsp_recexch_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_recexch_halving */ + "MPIR_Iallgatherv_intra_tsp_recexch_halving", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_ring */ + "MPIR_Iallgatherv_intra_tsp_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_inter_sched_remote_gather_local_bcast */ + "MPIR_Iallgatherv_inter_sched_remote_gather_local_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_naive */ + "MPIR_Iallreduce_intra_sched_naive", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_recursive_doubling */ + "MPIR_Iallreduce_intra_sched_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_reduce_scatter_allgather */ + "MPIR_Iallreduce_intra_sched_reduce_scatter_allgather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_single_buffer */ + "MPIR_Iallreduce_intra_tsp_recexch_single_buffer", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_multiple_buffer */ + "MPIR_Iallreduce_intra_tsp_recexch_multiple_buffer", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_tree */ + "MPIR_Iallreduce_intra_tsp_tree", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_ring */ + "MPIR_Iallreduce_intra_tsp_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_reduce_scatter_recexch_allgatherv */ + "MPIR_Iallreduce_intra_tsp_recexch_reduce_scatter_recexch_allgatherv", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_smp */ + "MPIR_Iallreduce_intra_sched_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_inter_sched_remote_reduce_local_bcast */ + "MPIR_Iallreduce_inter_sched_remote_reduce_local_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_ring */ + "MPIR_Ialltoall_intra_tsp_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_brucks */ + "MPIR_Ialltoall_intra_tsp_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_scattered */ + "MPIR_Ialltoall_intra_tsp_scattered", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_brucks */ + "MPIR_Ialltoall_intra_sched_brucks", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_inplace */ + "MPIR_Ialltoall_intra_sched_inplace", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_pairwise */ + "MPIR_Ialltoall_intra_sched_pairwise", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_permuted_sendrecv */ + "MPIR_Ialltoall_intra_sched_permuted_sendrecv", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_inter_sched_pairwise_exchange */ + "MPIR_Ialltoall_inter_sched_pairwise_exchange", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_sched_blocked */ + "MPIR_Ialltoallv_intra_sched_blocked", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_sched_inplace */ + "MPIR_Ialltoallv_intra_sched_inplace", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_scattered */ + "MPIR_Ialltoallv_intra_tsp_scattered", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_blocked */ + "MPIR_Ialltoallv_intra_tsp_blocked", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_inplace */ + "MPIR_Ialltoallv_intra_tsp_inplace", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_inter_sched_pairwise_exchange */ + "MPIR_Ialltoallv_inter_sched_pairwise_exchange", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_tsp_blocked */ + "MPIR_Ialltoallw_intra_tsp_blocked", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_tsp_inplace */ + "MPIR_Ialltoallw_intra_tsp_inplace", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_sched_blocked */ + "MPIR_Ialltoallw_intra_sched_blocked", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_sched_inplace */ + "MPIR_Ialltoallw_intra_sched_inplace", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_inter_sched_pairwise_exchange */ + "MPIR_Ialltoallw_inter_sched_pairwise_exchange", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_sched_recursive_doubling */ + "MPIR_Ibarrier_intra_sched_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_tsp_recexch */ + "MPIR_Ibarrier_intra_tsp_recexch", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_tsp_k_dissemination */ + "MPIR_Ibarrier_intra_tsp_k_dissemination", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_inter_sched_bcast */ + "MPIR_Ibarrier_inter_sched_bcast", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_tree */ + "MPIR_Ibcast_intra_tsp_tree", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_scatterv_recexch_allgatherv */ + "MPIR_Ibcast_intra_tsp_scatterv_recexch_allgatherv", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_scatterv_ring_allgatherv */ + "MPIR_Ibcast_intra_tsp_scatterv_ring_allgatherv", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_ring */ + "MPIR_Ibcast_intra_tsp_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_binomial */ + "MPIR_Ibcast_intra_sched_binomial", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_scatter_recursive_doubling_allgather */ + "MPIR_Ibcast_intra_sched_scatter_recursive_doubling_allgather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_scatter_ring_allgather */ + "MPIR_Ibcast_intra_sched_scatter_ring_allgather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_smp */ + "MPIR_Ibcast_intra_sched_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_inter_sched_flat */ + "MPIR_Ibcast_inter_sched_flat", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iexscan_intra_sched_recursive_doubling */ + "MPIR_Iexscan_intra_sched_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_intra_tsp_tree */ + "MPIR_Igather_intra_tsp_tree", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_intra_sched_binomial */ + "MPIR_Igather_intra_sched_binomial", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_inter_sched_long */ + "MPIR_Igather_inter_sched_long", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_inter_sched_short */ + "MPIR_Igather_inter_sched_short", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igatherv_allcomm_tsp_linear */ + "MPIR_Igatherv_allcomm_tsp_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igatherv_allcomm_sched_linear */ + "MPIR_Igatherv_allcomm_sched_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgather_allcomm_tsp_linear */ + "MPIR_Ineighbor_allgather_allcomm_tsp_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgather_allcomm_sched_linear */ + "MPIR_Ineighbor_allgather_allcomm_sched_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgatherv_allcomm_tsp_linear */ + "MPIR_Ineighbor_allgatherv_allcomm_tsp_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgatherv_allcomm_sched_linear */ + "MPIR_Ineighbor_allgatherv_allcomm_sched_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoall_allcomm_tsp_linear */ + "MPIR_Ineighbor_alltoall_allcomm_tsp_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoall_allcomm_sched_linear */ + "MPIR_Ineighbor_alltoall_allcomm_sched_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallv_allcomm_tsp_linear */ + "MPIR_Ineighbor_alltoallv_allcomm_tsp_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallv_allcomm_sched_linear */ + "MPIR_Ineighbor_alltoallv_allcomm_sched_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallw_allcomm_tsp_linear */ + "MPIR_Ineighbor_alltoallw_allcomm_tsp_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallw_allcomm_sched_linear */ + "MPIR_Ineighbor_alltoallw_allcomm_sched_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_tsp_tree */ + "MPIR_Ireduce_intra_tsp_tree", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_tsp_ring */ + "MPIR_Ireduce_intra_tsp_ring", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_binomial */ + "MPIR_Ireduce_intra_sched_binomial", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_reduce_scatter_gather */ + "MPIR_Ireduce_intra_sched_reduce_scatter_gather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_smp */ + "MPIR_Ireduce_intra_sched_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_inter_sched_local_reduce_remote_send */ + "MPIR_Ireduce_inter_sched_local_reduce_remote_send", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_noncommutative */ + "MPIR_Ireduce_scatter_intra_sched_noncommutative", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_pairwise */ + "MPIR_Ireduce_scatter_intra_sched_pairwise", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_recursive_doubling */ + "MPIR_Ireduce_scatter_intra_sched_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_recursive_halving */ + "MPIR_Ireduce_scatter_intra_sched_recursive_halving", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_tsp_recexch */ + "MPIR_Ireduce_scatter_intra_tsp_recexch", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_inter_sched_remote_reduce_local_scatterv */ + "MPIR_Ireduce_scatter_inter_sched_remote_reduce_local_scatterv", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_tsp_recexch */ + "MPIR_Ireduce_scatter_block_intra_tsp_recexch", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_noncommutative */ + "MPIR_Ireduce_scatter_block_intra_sched_noncommutative", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_pairwise */ + "MPIR_Ireduce_scatter_block_intra_sched_pairwise", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_recursive_doubling */ + "MPIR_Ireduce_scatter_block_intra_sched_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_recursive_halving */ + "MPIR_Ireduce_scatter_block_intra_sched_recursive_halving", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_inter_sched_remote_reduce_local_scatterv */ + "MPIR_Ireduce_scatter_block_inter_sched_remote_reduce_local_scatterv", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_sched_recursive_doubling */ + "MPIR_Iscan_intra_sched_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_sched_smp */ + "MPIR_Iscan_intra_sched_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_tsp_recursive_doubling */ + "MPIR_Iscan_intra_tsp_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_intra_tsp_tree */ + "MPIR_Iscatter_intra_tsp_tree", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_intra_sched_binomial */ + "MPIR_Iscatter_intra_sched_binomial", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_inter_sched_linear */ + "MPIR_Iscatter_inter_sched_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_inter_sched_remote_send_local_scatter */ + "MPIR_Iscatter_inter_sched_remote_send_local_scatter", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatterv_allcomm_tsp_linear */ + "MPIR_Iscatterv_allcomm_tsp_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatterv_allcomm_sched_linear */ + "MPIR_Iscatterv_allcomm_sched_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_allgather_allcomm_nb */ + "MPIR_Neighbor_allgather_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_allgatherv_allcomm_nb */ + "MPIR_Neighbor_allgatherv_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoall_allcomm_nb */ + "MPIR_Neighbor_alltoall_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoallv_allcomm_nb */ + "MPIR_Neighbor_alltoallv_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoallw_allcomm_nb */ + "MPIR_Neighbor_alltoallw_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_binomial */ + "MPIR_Reduce_intra_binomial", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_reduce_scatter_gather */ + "MPIR_Reduce_intra_reduce_scatter_gather", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_smp */ "MPIR_Reduce_intra_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_inter_local_reduce_remote_send */ + "MPIR_Reduce_inter_local_reduce_remote_send", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_allcomm_nb */ "MPIR_Reduce_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_noncommutative */ + "MPIR_Reduce_scatter_intra_noncommutative", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_pairwise */ + "MPIR_Reduce_scatter_intra_pairwise", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_recursive_doubling */ + "MPIR_Reduce_scatter_intra_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_recursive_halving */ + "MPIR_Reduce_scatter_intra_recursive_halving", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_inter_remote_reduce_local_scatter */ + "MPIR_Reduce_scatter_inter_remote_reduce_local_scatter", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_allcomm_nb */ + "MPIR_Reduce_scatter_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_noncommutative */ + "MPIR_Reduce_scatter_block_intra_noncommutative", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_pairwise */ + "MPIR_Reduce_scatter_block_intra_pairwise", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_recursive_doubling */ + "MPIR_Reduce_scatter_block_intra_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_recursive_halving */ + "MPIR_Reduce_scatter_block_intra_recursive_halving", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_inter_remote_reduce_local_scatter */ + "MPIR_Reduce_scatter_block_inter_remote_reduce_local_scatter", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_allcomm_nb */ + "MPIR_Reduce_scatter_block_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_intra_recursive_doubling */ + "MPIR_Scan_intra_recursive_doubling", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_intra_smp */ "MPIR_Scan_intra_smp", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_allcomm_nb */ "MPIR_Scan_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_intra_binomial */ + "MPIR_Scatter_intra_binomial", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_inter_linear */ + "MPIR_Scatter_inter_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_inter_remote_send_local_scatter */ + "MPIR_Scatter_inter_remote_send_local_scatter", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_allcomm_nb */ "MPIR_Scatter_allcomm_nb", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_linear */ + "MPIR_Scatterv_allcomm_linear", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_nb */ "MPIR_Scatterv_allcomm_nb", + + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_release_gather */ + "MPIDI_POSIX_mpi_bcast_release_gather", + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_ipc_read */ + "MPIDI_POSIX_mpi_bcast_ipc_read", + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_impl */ "MPIR_Bcast_impl", + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_barrier_release_gather */ + "MPIDI_POSIX_mpi_barrier_release_gather", + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_impl */ "MPIR_Barrier_impl", + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_allreduce_release_gather */ + "MPIDI_POSIX_mpi_allreduce_release_gather", + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_impl */ "MPIR_Allreduce_impl", + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather */ + "MPIDI_POSIX_mpi_reduce_release_gather", + /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl */ "MPIR_Reduce_impl", + + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count */ "END_OF_MPIR_ALGO" +}; diff --git a/src/mpi/coll/src/csel_internal.h b/src/mpi/coll/src/csel_internal.h new file mode 100644 index 00000000000..3a40a6c6cb7 --- /dev/null +++ b/src/mpi/coll/src/csel_internal.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) by Argonne National Laboratory + * See COPYRIGHT in top-level directory + */ + +#ifndef CSEL_INTERNAL_H_INCLUDED +#define CSEL_INTERNAL_H_INCLUDED + +#include "mpiimpl.h" +#include "mpir_csel.h" +#include + +typedef enum { + /* global operator types */ + CSEL_NODE_TYPE__OPERATOR__IS_MULTI_THREADED = 0, + + /* comm-specific operator types */ + CSEL_NODE_TYPE__OPERATOR__COMM_TYPE_INTRA, + CSEL_NODE_TYPE__OPERATOR__COMM_TYPE_INTER, + + CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_LE, + CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_LT, + CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_NODE_COMM_SIZE, + CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_POW2, + + CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY, + CSEL_NODE_TYPE__OPERATOR__IS_NODE_CONSECUTIVE, + + CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LE, + CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LT, + + /* collective selection operator */ + CSEL_NODE_TYPE__OPERATOR__COLLECTIVE, + + /* message-specific operator types */ + CSEL_NODE_TYPE__OPERATOR__AVG_MSG_SIZE_LE, + CSEL_NODE_TYPE__OPERATOR__AVG_MSG_SIZE_LT, + CSEL_NODE_TYPE__OPERATOR__TOTAL_MSG_SIZE_LE, + CSEL_NODE_TYPE__OPERATOR__TOTAL_MSG_SIZE_LT, + + CSEL_NODE_TYPE__OPERATOR__COUNT_LE, + CSEL_NODE_TYPE__OPERATOR__COUNT_LT_POW2, + + CSEL_NODE_TYPE__OPERATOR__IS_SBUF_INPLACE, + CSEL_NODE_TYPE__OPERATOR__IS_BLOCK_REGULAR, + CSEL_NODE_TYPE__OPERATOR__IS_COMMUTATIVE, + CSEL_NODE_TYPE__OPERATOR__IS_OP_BUILT_IN, + + /* any - has to be the last branch in an array */ + CSEL_NODE_TYPE__OPERATOR__ANY, + + /* container type */ + CSEL_NODE_TYPE__CONTAINER, +} csel_node_type_e; + +typedef struct csel_node { + csel_node_type_e type; + + union { + /* global types */ + struct { + int val; + } is_multi_threaded; + + /* comm-specific operator types */ + struct { + int val; + } comm_size_le; + struct { + int val; + } comm_size_lt; + + /* collective selection operator */ + struct { + MPIR_Csel_coll_type_e coll_type; + } collective; + + /* message-specific operator types */ + struct { + int val; + } avg_msg_size_le; + struct { + int val; + } avg_msg_size_lt; + struct { + int val; + } total_msg_size_le; + struct { + int val; + } total_msg_size_lt; + struct { + int val; + } count_le; + struct { + bool val; + } is_commutative; + struct { + bool val; + } is_sbuf_inplace; + struct { + bool val; + } is_op_built_in; + struct { + bool val; + } is_block_regular; + struct { + bool val; + } is_node_consecutive; + struct { + int val; + } comm_avg_ppn_le; + struct { + int val; + } comm_avg_ppn_lt; + struct { + int val; + } comm_hierarchy; + struct { + void *container; + } cnt; + } u; + + struct csel_node *success; + struct csel_node *failure; +} csel_node_s; + +typedef enum { + CSEL_TYPE__ROOT, + CSEL_TYPE__PRUNED, +} csel_type_e; + +typedef struct { + csel_type_e type; + + union { + struct { + csel_node_s *tree; + } root; + struct { + /* one tree for each collective */ + csel_node_s *coll_trees[MPIR_CSEL_COLL_TYPE__END]; + } pruned; + } u; +} csel_s; + +extern const char *Csel_coll_type_str[]; +extern const char *Csel_comm_hierarchy_str[]; +extern const char *Csel_container_type_str[]; + +void Csel_print_node(csel_node_s * node); +void Csel_print_container(MPII_Csel_container_s * cnt); +void Csel_print_tree(csel_node_s * node); +void Csel_print_rules(csel_node_s * node); + +#endif /* CSEL_INTERNAL_CONTAINER_H_INCLUDED */ diff --git a/src/mpi/coll/src/csel_print.c b/src/mpi/coll/src/csel_print.c new file mode 100644 index 00000000000..124a01ecc00 --- /dev/null +++ b/src/mpi/coll/src/csel_print.c @@ -0,0 +1,220 @@ +/* + * Copyright (C) by Argonne National Laboratory + * See COPYRIGHT in top-level directory + */ + +#include "mpiimpl.h" +#include "csel_internal.h" +#include "utlist.h" + +static int nesting = -1; + +#define printf_indent(indent) \ + do { \ + for (int nindent = 0; nindent < (indent); nindent++) \ + printf(" "); \ + } while (0) + +#define printf_newline() \ + do { \ + printf("\n"); \ + } while (0) + +struct Csel_decision_rule; +typedef struct Csel_decision_rule { + int size; + int algorithm; + csel_node_s **path; + struct Csel_decision_rule *prev, *next; +} Csel_decision_rule; + +void Csel_print_tree(csel_node_s * node) +{ + nesting++; + + if (node == NULL) { + return; + } + + printf_indent(nesting); + Csel_print_node(node); + printf_newline(); + + if (node->type != CSEL_NODE_TYPE__CONTAINER) { + Csel_print_tree(node->success); + if (node->failure) { + nesting--; + Csel_print_tree(node->failure); + nesting++; + } + } + + nesting--; +} + +void Csel_print_container(MPII_Csel_container_s * cnt) +{ + printf("Algorithm: %s\n", Csel_container_type_str[cnt->id]); +} + +void Csel_print_node(csel_node_s * node) +{ + if (node == NULL) { + return; + } + + switch (node->type) { + case CSEL_NODE_TYPE__OPERATOR__IS_MULTI_THREADED: + printf("MPI library is multithreaded"); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_TYPE_INTRA: + printf("intra_comm"); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_TYPE_INTER: + printf("inter_comm"); + break; + case CSEL_NODE_TYPE__OPERATOR__COLLECTIVE: + printf("collective: %s", Csel_coll_type_str[node->u.collective.coll_type]); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_LE: + printf("comm_size <= %d", node->u.comm_size_le.val); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_LT: + printf("comm_size < %d", node->u.comm_size_lt.val); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_POW2: + printf("comm_size is power-of-two"); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_SIZE_NODE_COMM_SIZE: + printf("comm_size == node_comm_size"); + break; + case CSEL_NODE_TYPE__OPERATOR__AVG_MSG_SIZE_LE: + printf("avg_msg_size <= %d", node->u.avg_msg_size_le.val); + break; + case CSEL_NODE_TYPE__OPERATOR__AVG_MSG_SIZE_LT: + printf("avg_msg_size < %d", node->u.avg_msg_size_lt.val); + break; + case CSEL_NODE_TYPE__OPERATOR__TOTAL_MSG_SIZE_LE: + printf("total_msg_size <= %d", node->u.total_msg_size_le.val); + break; + case CSEL_NODE_TYPE__OPERATOR__TOTAL_MSG_SIZE_LT: + printf("total_msg_size < %d", node->u.total_msg_size_lt.val); + break; + case CSEL_NODE_TYPE__CONTAINER: + Csel_print_container(node->u.cnt.container); + break; + case CSEL_NODE_TYPE__OPERATOR__COUNT_LE: + printf("count <= %d", node->u.count_le.val); + break; + case CSEL_NODE_TYPE__OPERATOR__COUNT_LT_POW2: + printf("count < nearest power-of-two less than comm size"); + break; + case CSEL_NODE_TYPE__OPERATOR__IS_SBUF_INPLACE: + printf("source buffer is MPI_IN_PLACE"); + break; + case CSEL_NODE_TYPE__OPERATOR__IS_BLOCK_REGULAR: + printf("all blocks have the same count"); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_HIERARCHY: + printf("comm hierarchy is: %s", Csel_comm_hierarchy_str[node->u.comm_hierarchy.val]); + break; + case CSEL_NODE_TYPE__OPERATOR__IS_NODE_CONSECUTIVE: + printf("process ranks are consecutive on the node"); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LE: + printf("comm avg ppn <= %d", node->u.comm_avg_ppn_le.val); + break; + case CSEL_NODE_TYPE__OPERATOR__COMM_AVG_PPN_LT: + printf("comm avg ppn < %d", node->u.comm_avg_ppn_lt.val); + break; + case CSEL_NODE_TYPE__OPERATOR__IS_COMMUTATIVE: + if (node->u.is_commutative.val == true) + printf("commutative OP"); + else + printf("not commutative OP"); + break; + case CSEL_NODE_TYPE__OPERATOR__IS_OP_BUILT_IN: + printf("built-in OP"); + break; + case CSEL_NODE_TYPE__OPERATOR__ANY: + printf("any"); + break; + default: + printf("unknown operator"); + MPIR_Assert(0); + } +} + +static csel_node_s *decision_path[128] = { 0 }; +static Csel_decision_rule *algorithms[MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count] = { 0 }; + +static void collect_rules(csel_node_s * node); + +void collect_rules(csel_node_s * node) +{ + nesting++; + + if (node == NULL) { + return; + } + + if (node->type == CSEL_NODE_TYPE__CONTAINER) { + int alg_id = ((MPII_Csel_container_s *) node->u.cnt.container)->id; + /* save decision path */ + Csel_decision_rule *new_rule = + (Csel_decision_rule *) MPL_malloc(sizeof(Csel_decision_rule), MPL_MEM_OTHER); + new_rule->size = nesting; + new_rule->algorithm = alg_id; + new_rule->path = + (csel_node_s **) MPL_malloc(sizeof(csel_node_s *) * nesting, MPL_MEM_OTHER); + memcpy(new_rule->path, decision_path, sizeof(csel_node_s *) * new_rule->size); + DL_APPEND(algorithms[alg_id], new_rule); + } else { + decision_path[nesting] = node; + collect_rules(node->success); + if (node->failure) { + nesting--; + collect_rules(node->failure); + nesting++; + } + } + nesting--; +} + +void Csel_print_rules(csel_node_s * node) +{ + memset(decision_path, 0, sizeof(csel_node_s *) * 128); + memset(algorithms, 0, + sizeof(Csel_decision_rule *) * MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count); + + collect_rules(node); + + for (int i = 0; i < MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count; i++) { + if (algorithms[i] != NULL) { + printf("%s\n", Csel_container_type_str[i]); + if (algorithms[i] == NULL) { + continue; + } else { + Csel_decision_rule *iter = NULL, *temp = NULL; + if (algorithms[i]->size == 1) { + printf_indent(1); + printf(" >>> any\n"); + MPL_free(algorithms[i]->path); + MPL_free(algorithms[i]); + } else { + DL_FOREACH_SAFE(algorithms[i], iter, temp) { + printf_indent(1); + for (int j = 1; j < iter->size; j++) { + printf(" >>> "); + Csel_print_node(iter->path[j]); + } + printf_newline(); + DL_DELETE(algorithms[i], iter); + MPL_free(iter->path); + MPL_free(iter); + } + } + } + } + } +} From 5ac8a074557e0e7c49ab3ff80c2bd0efdd74cfc7 Mon Sep 17 00:00:00 2001 From: Yanfei Guo Date: Thu, 17 Jul 2025 13:53:48 -0500 Subject: [PATCH 2/6] coll: merge json processing of posix algorithms Consolidate the POSIX coll algorithm enum definition under MPII. The JSON parsing no longer need separate functions for them. --- src/mpi/coll/include/csel_container.h | 11 + src/mpi/coll/src/csel_constants.c | 18 +- src/mpi/coll/src/csel_container.c | 476 +----------------- src/mpid/ch4/shm/posix/posix_coll.h | 30 +- src/mpid/ch4/shm/posix/posix_csel_container.h | 23 - src/mpid/ch4/shm/posix/posix_init.c | 47 +- 6 files changed, 57 insertions(+), 548 deletions(-) delete mode 100644 src/mpid/ch4/shm/posix/posix_csel_container.h diff --git a/src/mpi/coll/include/csel_container.h b/src/mpi/coll/include/csel_container.h index fae6ea479e4..b082ca619a0 100644 --- a/src/mpi/coll/include/csel_container.h +++ b/src/mpi/coll/include/csel_container.h @@ -204,6 +204,17 @@ typedef enum { MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_allcomm_nb, MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_linear, MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_nb, + + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_release_gather, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_ipc_read, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_impl, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_barrier_release_gather, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_impl, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_allreduce_release_gather, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_impl, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count, } MPII_Csel_container_type_e; diff --git a/src/mpi/coll/src/csel_constants.c b/src/mpi/coll/src/csel_constants.c index ddf81022a29..cf0fab2b9e1 100644 --- a/src/mpi/coll/src/csel_constants.c +++ b/src/mpi/coll/src/csel_constants.c @@ -432,20 +432,20 @@ const char *Csel_container_type_str[] = { "MPIR_Scatterv_allcomm_linear", /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_nb */ "MPIR_Scatterv_allcomm_nb", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_release_gather */ + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_release_gather */ "MPIDI_POSIX_mpi_bcast_release_gather", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_ipc_read */ + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_ipc_read */ "MPIDI_POSIX_mpi_bcast_ipc_read", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_impl */ "MPIR_Bcast_impl", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_barrier_release_gather */ + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_impl */ "MPIR_Bcast_impl", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_barrier_release_gather */ "MPIDI_POSIX_mpi_barrier_release_gather", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_impl */ "MPIR_Barrier_impl", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_allreduce_release_gather */ + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_impl */ "MPIR_Barrier_impl", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_allreduce_release_gather */ "MPIDI_POSIX_mpi_allreduce_release_gather", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_impl */ "MPIR_Allreduce_impl", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather */ + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_impl */ "MPIR_Allreduce_impl", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather */ "MPIDI_POSIX_mpi_reduce_release_gather", - /* MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl */ "MPIR_Reduce_impl", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl */ "MPIR_Reduce_impl", /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count */ "END_OF_MPIR_ALGO" }; diff --git a/src/mpi/coll/src/csel_container.c b/src/mpi/coll/src/csel_container.c index 92563c69d43..3978dfca9eb 100644 --- a/src/mpi/coll/src/csel_container.c +++ b/src/mpi/coll/src/csel_container.c @@ -6,6 +6,7 @@ #include "mpiimpl.h" #include "coll_impl.h" #include "csel_container.h" +#include "csel_internal.h" #include "mpl.h" static void parse_container_params(struct json_object *obj, MPII_Csel_container_s * cnt) @@ -380,466 +381,21 @@ void *MPII_Create_container(struct json_object *obj) json_object_object_foreach(obj, key, val) { char *ckey = MPL_strdup_no_spaces(key); - if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_k_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_k_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_recursive_doubling")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_recexch_doubling")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recexch_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Allgather_intra_recexch_halving")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_intra_recexch_halving; - else if (!strcmp(ckey, "algorithm=MPIR_Allgather_inter_local_gather_remote_bcast")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_inter_local_gather_remote_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Allgather_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgather_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_intra_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_intra_recursive_doubling")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_intra_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_intra_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_inter_remote_gather_local_bcast")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_inter_remote_gather_local_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Allgatherv_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allgatherv_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_recursive_doubling")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_recursive_multiplying")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recursive_multiplying; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_reduce_scatter_allgather")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_reduce_scatter_allgather; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_tree")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_tree; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_recexch")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_recexch; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_intra_k_reduce_scatter_allgather")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_intra_k_reduce_scatter_allgather; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_inter_reduce_exchange_bcast")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_inter_reduce_exchange_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Allreduce_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_k_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_k_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_pairwise")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_pairwise; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_pairwise_sendrecv_replace")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_pairwise_sendrecv_replace; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_intra_scattered")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_intra_scattered; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_inter_pairwise_exchange")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_inter_pairwise_exchange; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoall_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoall_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoallv_intra_pairwise_sendrecv_replace")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_intra_pairwise_sendrecv_replace; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoallv_intra_scattered")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_intra_scattered; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoallv_inter_pairwise_exchange")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_inter_pairwise_exchange; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoallv_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallv_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoallw_intra_pairwise_sendrecv_replace")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_intra_pairwise_sendrecv_replace; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoallw_intra_scattered")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_intra_scattered; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoallw_inter_pairwise_exchange")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_inter_pairwise_exchange; - else if (!strcmp(ckey, "algorithm=MPIR_Alltoallw_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Alltoallw_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Barrier_intra_k_dissemination")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_k_dissemination; - else if (!strcmp(ckey, "algorithm=MPIR_Barrier_intra_recexch")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_recexch; - else if (!strcmp(ckey, "algorithm=MPIR_Barrier_intra_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_intra_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Barrier_inter_bcast")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_inter_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Barrier_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_binomial")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_binomial; - else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_scatter_recursive_doubling_allgather")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_scatter_recursive_doubling_allgather; - else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_scatter_ring_allgather")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_scatter_ring_allgather; - else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_tree")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_tree; - else if (!strcmp(ckey, "algorithm=MPIR_Bcast_intra_pipelined_tree")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_intra_pipelined_tree; - else if (!strcmp(ckey, "algorithm=MPIR_Bcast_inter_remote_send_local_bcast")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_inter_remote_send_local_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Bcast_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Exscan_intra_recursive_doubling")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Exscan_intra_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Exscan_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Exscan_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Gather_intra_binomial")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_intra_binomial; - else if (!strcmp(ckey, "algorithm=MPIR_Gather_inter_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_inter_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Gather_inter_local_gather_remote_send")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_inter_local_gather_remote_send; - else if (!strcmp(ckey, "algorithm=MPIR_Gather_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gather_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Gatherv_allcomm_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gatherv_allcomm_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Gatherv_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Gatherv_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_tsp_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_sched_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_sched_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_sched_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_sched_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_tsp_recexch_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_recexch_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_tsp_recexch_halving")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_recexch_halving; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_intra_tsp_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_intra_tsp_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgather_inter_sched_local_gather_remote_bcast")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgather_inter_sched_local_gather_remote_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_tsp_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_sched_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_sched_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_sched_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_sched_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_tsp_recexch_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_recexch_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_tsp_recexch_halving")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_recexch_halving; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_intra_tsp_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_intra_tsp_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Iallgatherv_inter_sched_remote_gather_local_bcast")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallgatherv_inter_sched_remote_gather_local_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_sched_naive")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_naive; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_sched_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_sched_reduce_scatter_allgather")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_reduce_scatter_allgather; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_tsp_recexch_single_buffer")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_single_buffer; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_tsp_recexch_multiple_buffer")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_multiple_buffer; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_tsp_tree")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_tree; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_tsp_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_ring; - else if (!strcmp - (ckey, - "algorithm=MPIR_Iallreduce_intra_tsp_recexch_reduce_scatter_recexch_allgatherv")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_tsp_recexch_reduce_scatter_recexch_allgatherv; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_intra_sched_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_intra_sched_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Iallreduce_inter_sched_remote_reduce_local_bcast")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iallreduce_inter_sched_remote_reduce_local_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_tsp_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_tsp_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_tsp_scattered")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_tsp_scattered; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_sched_brucks")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_brucks; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_sched_inplace")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_inplace; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_sched_pairwise")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_pairwise; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_intra_sched_permuted_sendrecv")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_intra_sched_permuted_sendrecv; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoall_inter_sched_pairwise_exchange")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoall_inter_sched_pairwise_exchange; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_sched_blocked")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_sched_blocked; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_sched_inplace")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_sched_inplace; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_tsp_scattered")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_scattered; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_tsp_blocked")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_blocked; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_intra_tsp_inplace")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_intra_tsp_inplace; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallv_inter_sched_pairwise_exchange")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallv_inter_sched_pairwise_exchange; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_intra_tsp_blocked")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_tsp_blocked; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_intra_tsp_inplace")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_tsp_inplace; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_intra_sched_blocked")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_sched_blocked; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_intra_sched_inplace")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_intra_sched_inplace; - else if (!strcmp(ckey, "algorithm=MPIR_Ialltoallw_inter_sched_pairwise_exchange")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ialltoallw_inter_sched_pairwise_exchange; - else if (!strcmp(ckey, "algorithm=MPIR_Ibarrier_intra_sched_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_sched_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Ibarrier_intra_tsp_recexch")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_tsp_recexch; - else if (!strcmp(ckey, "algorithm=MPIR_Ibarrier_intra_tsp_k_dissem")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_intra_tsp_k_dissemination; - else if (!strcmp(ckey, "algorithm=MPIR_Ibarrier_inter_sched_bcast")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibarrier_inter_sched_bcast; - else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_tsp_tree")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_tree; - else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_tsp_scatterv_recexch_allgatherv")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_scatterv_recexch_allgatherv; - else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_tsp_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_tsp_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_sched_binomial")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_binomial; - else if (!strcmp - (ckey, "algorithm=MPIR_Ibcast_intra_sched_scatter_recursive_doubling_allgather")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_scatter_recursive_doubling_allgather; - else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_sched_scatter_ring_allgather")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_scatter_ring_allgather; - else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_intra_sched_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_intra_sched_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Ibcast_inter_sched_flat")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ibcast_inter_sched_flat; - else if (!strcmp(ckey, "algorithm=MPIR_Iexscan_intra_sched_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iexscan_intra_sched_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Igather_intra_tsp_tree")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_intra_tsp_tree; - else if (!strcmp(ckey, "algorithm=MPIR_Igather_intra_sched_binomial")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_intra_sched_binomial; - else if (!strcmp(ckey, "algorithm=MPIR_Igather_inter_sched_long")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_inter_sched_long; - else if (!strcmp(ckey, "algorithm=MPIR_Igather_inter_sched_short")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igather_inter_sched_short; - else if (!strcmp(ckey, "algorithm=MPIR_Igatherv_allcomm_tsp_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igatherv_allcomm_tsp_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Igatherv_allcomm_sched_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Igatherv_allcomm_sched_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_allgather_allcomm_tsp_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgather_allcomm_tsp_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_allgather_allcomm_sched_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgather_allcomm_sched_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_allgatherv_allcomm_tsp_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgatherv_allcomm_tsp_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_allgatherv_allcomm_sched_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_allgatherv_allcomm_sched_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoall_allcomm_tsp_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoall_allcomm_tsp_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoall_allcomm_sched_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoall_allcomm_sched_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoallv_allcomm_tsp_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallv_allcomm_tsp_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoallv_allcomm_sched_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallv_allcomm_sched_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoallw_allcomm_tsp_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallw_allcomm_tsp_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ineighbor_alltoallw_allcomm_sched_linear")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ineighbor_alltoallw_allcomm_sched_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_tsp_tree")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_tsp_tree; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_tsp_ring")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_tsp_ring; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_sched_binomial")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_binomial; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_sched_reduce_scatter_gather")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_reduce_scatter_gather; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_intra_sched_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_intra_sched_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_inter_sched_local_reduce_remote_send")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_inter_sched_local_reduce_remote_send; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_sched_noncommutative")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_noncommutative; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_sched_pairwise")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_pairwise; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_sched_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_sched_recursive_halving")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_sched_recursive_halving; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_intra_tsp_recexch")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_intra_tsp_recexch; - else if (!strcmp - (ckey, "algorithm=MPIR_Ireduce_scatter_inter_sched_remote_reduce_local_scatterv")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_inter_sched_remote_reduce_local_scatterv; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_tsp_recexch")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_tsp_recexch; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_sched_noncommutative")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_noncommutative; - else if (!strcmp(ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_sched_pairwise")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_pairwise; - else if (!strcmp - (ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_sched_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_recursive_doubling; - else if (!strcmp - (ckey, "algorithm=MPIR_Ireduce_scatter_block_intra_sched_recursive_halving")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_intra_sched_recursive_halving; - else if (!strcmp - (ckey, - "algorithm=MPIR_Ireduce_scatter_block_inter_sched_remote_reduce_local_scatterv")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Ireduce_scatter_block_inter_sched_remote_reduce_local_scatterv; - else if (!strcmp(ckey, "algorithm=MPIR_Iscan_intra_sched_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_sched_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Iscan_intra_sched_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_sched_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Iscan_intra_tsp_recursive_doubling")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscan_intra_tsp_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Iscatter_intra_tsp_tree")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_intra_tsp_tree; - else if (!strcmp(ckey, "algorithm=MPIR_Iscatter_intra_sched_binomial")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_intra_sched_binomial; - else if (!strcmp(ckey, "algorithm=MPIR_Iscatter_inter_sched_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_inter_sched_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Iscatter_inter_sched_remote_send_local_scatter")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatter_inter_sched_remote_send_local_scatter; - else if (!strcmp(ckey, "algorithm=MPIR_Iscatterv_allcomm_tsp_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatterv_allcomm_tsp_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Iscatterv_allcomm_sched_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Iscatterv_allcomm_sched_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_allgather_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_allgather_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_allgatherv_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_allgatherv_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_alltoall_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoall_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_alltoallv_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoallv_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Neighbor_alltoallw_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Neighbor_alltoallw_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_intra_binomial")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_binomial; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_intra_reduce_scatter_gather")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_reduce_scatter_gather; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_intra_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_intra_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_inter_local_reduce_remote_send")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_inter_local_reduce_remote_send; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_intra_noncommutative")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_noncommutative; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_intra_pairwise")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_pairwise; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_intra_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_intra_recursive_halving")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_intra_recursive_halving; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_inter_remote_reduce_local_scatter")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_inter_remote_reduce_local_scatter; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_intra_noncommutative")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_noncommutative; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_intra_pairwise")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_pairwise; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_intra_recursive_doubling")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_intra_recursive_halving")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_intra_recursive_halving; - else if (!strcmp - (ckey, "algorithm=MPIR_Reduce_scatter_block_inter_remote_reduce_local_scatter")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_inter_remote_reduce_local_scatter; - else if (!strcmp(ckey, "algorithm=MPIR_Reduce_scatter_block_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_scatter_block_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Scan_intra_recursive_doubling")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_intra_recursive_doubling; - else if (!strcmp(ckey, "algorithm=MPIR_Scan_intra_smp")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_intra_smp; - else if (!strcmp(ckey, "algorithm=MPIR_Scan_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scan_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Scatter_intra_binomial")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_intra_binomial; - else if (!strcmp(ckey, "algorithm=MPIR_Scatter_inter_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_inter_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Scatter_inter_remote_send_local_scatter")) - cnt->id = - MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_inter_remote_send_local_scatter; - else if (!strcmp(ckey, "algorithm=MPIR_Scatter_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatter_allcomm_nb; - else if (!strcmp(ckey, "algorithm=MPIR_Scatterv_allcomm_linear")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_linear; - else if (!strcmp(ckey, "algorithm=MPIR_Scatterv_allcomm_nb")) - cnt->id = MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Scatterv_allcomm_nb; - else { + if (!strncmp(ckey, "algorithm=", strlen("algorithm="))) { + char *str = ckey + strlen("algorithm="); + + bool matched = false; + for (int idx = 0; idx < MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count; idx++) { + if (strcmp(str, Csel_container_type_str[idx]) == 0) { + cnt->id = idx; + matched = true; + break; + } + } + if (!matched) { + MPIR_Assert(0); + } + } else { fprintf(stderr, "unrecognized key %s\n", key); MPIR_Assert(0); } diff --git a/src/mpid/ch4/shm/posix/posix_coll.h b/src/mpid/ch4/shm/posix/posix_coll.h index f45015d25f8..9f41f1b712b 100644 --- a/src/mpid/ch4/shm/posix/posix_coll.h +++ b/src/mpid/ch4/shm/posix/posix_coll.h @@ -10,7 +10,6 @@ #include "ch4_impl.h" #include "posix_coll_release_gather.h" #include "posix_coll_gpu_ipc.h" -#include "posix_csel_container.h" /* @@ -155,7 +154,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_POSIX_mpi_barrier(MPIR_Comm * comm, int coll_ .coll_type = MPIR_CSEL_COLL_TYPE__BARRIER, .comm_ptr = comm, }; - MPIDI_POSIX_csel_container_s *cnt; + MPII_Csel_container_s *cnt; MPIR_FUNC_ENTER; @@ -175,11 +174,10 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_POSIX_mpi_barrier(MPIR_Comm * comm, int coll_ goto fallback; switch (cnt->id) { - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_barrier_release_gather: - mpi_errno = - MPIDI_POSIX_mpi_barrier_release_gather(comm, coll_attr); + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_barrier_release_gather: + mpi_errno = MPIDI_POSIX_mpi_barrier_release_gather(comm, coll_attr); break; - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_impl: + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_impl: goto fallback; default: MPIR_Assert(0); @@ -217,7 +215,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_POSIX_mpi_bcast(void *buffer, MPI_Aint count, .u.bcast.datatype = datatype, .u.bcast.root = root, }; - MPIDI_POSIX_csel_container_s *cnt; + MPII_Csel_container_s *cnt; MPIR_FUNC_ENTER; @@ -255,17 +253,17 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_POSIX_mpi_bcast(void *buffer, MPI_Aint count, goto fallback; switch (cnt->id) { - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_release_gather: + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_release_gather: mpi_errno = MPIDI_POSIX_mpi_bcast_release_gather(buffer, count, datatype, root, comm, coll_attr); break; - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_ipc_read: + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_ipc_read: mpi_errno = MPIDI_POSIX_mpi_bcast_gpu_ipc_read(buffer, count, datatype, root, comm, coll_attr); break; - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_impl: + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_impl: goto fallback; default: MPIR_Assert(0); @@ -304,7 +302,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_POSIX_mpi_allreduce(const void *sendbuf, void .u.allreduce.datatype = datatype, .u.allreduce.op = op, }; - MPIDI_POSIX_csel_container_s *cnt; + MPII_Csel_container_s *cnt; MPIR_FUNC_ENTER; @@ -327,13 +325,13 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_POSIX_mpi_allreduce(const void *sendbuf, void goto fallback; switch (cnt->id) { - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_allreduce_release_gather: + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_allreduce_release_gather: mpi_errno = MPIDI_POSIX_mpi_allreduce_release_gather(sendbuf, recvbuf, count, datatype, op, comm, coll_attr); break; - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_impl: + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_impl: goto fallback; default: @@ -637,7 +635,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_POSIX_mpi_reduce(const void *sendbuf, void *r .u.reduce.op = op, .u.reduce.root = root, }; - MPIDI_POSIX_csel_container_s *cnt; + MPII_Csel_container_s *cnt; MPIR_FUNC_ENTER; @@ -660,13 +658,13 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_POSIX_mpi_reduce(const void *sendbuf, void *r goto fallback; switch (cnt->id) { - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather: + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather: mpi_errno = MPIDI_POSIX_mpi_reduce_release_gather(sendbuf, recvbuf, count, datatype, op, root, comm, coll_attr); break; - case MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl: + case MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl: goto fallback; default: diff --git a/src/mpid/ch4/shm/posix/posix_csel_container.h b/src/mpid/ch4/shm/posix/posix_csel_container.h deleted file mode 100644 index 00fe8ece728..00000000000 --- a/src/mpid/ch4/shm/posix/posix_csel_container.h +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright (C) by Argonne National Laboratory - * See COPYRIGHT in top-level directory - */ - -#ifndef POSIX_CSEL_CONTAINER_H_INCLUDED -#define POSIX_CSEL_CONTAINER_H_INCLUDED - -typedef struct { - enum { - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_release_gather, - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_ipc_read, - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_impl, - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_barrier_release_gather, - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Barrier_impl, - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_allreduce_release_gather, - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Allreduce_impl, - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather, - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl, - } id; -} MPIDI_POSIX_csel_container_s; - -#endif /* POSIX_CSEL_CONTAINER_H_INCLUDED */ diff --git a/src/mpid/ch4/shm/posix/posix_init.c b/src/mpid/ch4/shm/posix/posix_init.c index 5f4b82f36b6..c184b60be26 100644 --- a/src/mpid/ch4/shm/posix/posix_init.c +++ b/src/mpid/ch4/shm/posix/posix_init.c @@ -56,7 +56,6 @@ #include "posix_eager.h" #include "posix_noinline.h" -#include "posix_csel_container.h" #include "mpidu_genq.h" #include "utarray.h" @@ -121,39 +120,6 @@ static int choose_posix_eager(void) goto fn_exit; } -static void *create_container(struct json_object *obj) -{ - MPIDI_POSIX_csel_container_s *cnt = - MPL_malloc(sizeof(MPIDI_POSIX_csel_container_s), MPL_MEM_COLL); - - json_object_object_foreach(obj, key, val) { - char *ckey = MPL_strdup_no_spaces(key); - - if (!strcmp(ckey, "algorithm=MPIDI_POSIX_mpi_bcast_release_gather")) - cnt->id = - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_release_gather; - else if (!strcmp(ckey, "algorithm=MPIDI_POSIX_mpi_bcast_ipc_read")) - cnt->id = MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_bcast_ipc_read; - else if (!strcmp(ckey, "algorithm=MPIDI_POSIX_mpi_barrier_release_gather")) - cnt->id = - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_barrier_release_gather; - else if (!strcmp(ckey, "algorithm=MPIDI_POSIX_mpi_allreduce_release_gather")) - cnt->id = - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_allreduce_release_gather; - else if (!strcmp(ckey, "algorithm=MPIDI_POSIX_mpi_reduce_release_gather")) - cnt->id = - MPIDI_POSIX_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather; - else { - fprintf(stderr, "unrecognized key %s\n", key); - MPIR_Assert(0); - } - - MPL_free(ckey); - } - - return cnt; -} - int MPIDI_POSIX_init_vci(int vci) { int mpi_errno = MPI_SUCCESS; @@ -413,26 +379,27 @@ static int posix_coll_init(void) /* Initialize collective selection */ if (!strcmp(MPIR_CVAR_CH4_POSIX_COLL_SELECTION_TUNING_JSON_FILE, "")) { - mpi_errno = MPIR_Csel_create_from_buf(MPIDI_POSIX_coll_generic_json, - create_container, &MPIDI_global.shm.posix.csel_root); + mpi_errno = MPIR_Csel_create_from_buf(MPIDI_POSIX_coll_generic_json, MPII_Create_container, + &MPIDI_global.shm.posix.csel_root); MPIDI_global.shm.posix.csel_source = "MPIDI_POSIX_coll_generic_json"; } else { mpi_errno = MPIR_Csel_create_from_file(MPIR_CVAR_CH4_POSIX_COLL_SELECTION_TUNING_JSON_FILE, - create_container, &MPIDI_global.shm.posix.csel_root); + MPII_Create_container, + &MPIDI_global.shm.posix.csel_root); MPIDI_global.shm.posix.csel_source = MPIR_CVAR_CH4_POSIX_COLL_SELECTION_TUNING_JSON_FILE; } MPIR_ERR_CHECK(mpi_errno); /* Initialize collective selection for gpu */ if (!strcmp(MPIR_CVAR_CH4_POSIX_COLL_SELECTION_TUNING_JSON_FILE_GPU, "")) { - mpi_errno = MPIR_Csel_create_from_buf(MPIDI_POSIX_coll_generic_json, - create_container, + mpi_errno = MPIR_Csel_create_from_buf(MPIDI_POSIX_coll_generic_json, MPII_Create_container, &MPIDI_global.shm.posix.csel_root_gpu); MPIDI_global.shm.posix.csel_source_gpu = "MPIDI_POSIX_coll_generic_json"; } else { mpi_errno = MPIR_Csel_create_from_file(MPIR_CVAR_CH4_POSIX_COLL_SELECTION_TUNING_JSON_FILE_GPU, - create_container, &MPIDI_global.shm.posix.csel_root_gpu); + MPII_Create_container, + &MPIDI_global.shm.posix.csel_root_gpu); MPIDI_global.shm.posix.csel_source_gpu = MPIR_CVAR_CH4_POSIX_COLL_SELECTION_TUNING_JSON_FILE_GPU; } From 4936190573d79a28a30497bbac5048eb191f3790 Mon Sep 17 00:00:00 2001 From: Yanfei Guo Date: Thu, 17 Jul 2025 15:20:42 -0500 Subject: [PATCH 3/6] coll: merge json processing of ch4 algorithms Consolidate the CH4 coll algorithm enum definition under MPII. The JSON parsing no longer need separate functions for them. --- src/mpi/coll/include/csel_container.h | 30 +++++++++ src/mpi/coll/src/csel_constants.c | 59 +++++++++++++++++ src/mpi/coll/src/csel_container.c | 14 ++++ src/mpid/ch4/include/mpidpre.h | 1 - src/mpid/ch4/src/ch4_coll.h | 92 +++++++++++++------------- src/mpid/ch4/src/ch4_coll_impl.h | 1 - src/mpid/ch4/src/ch4_csel_container.h | 43 ------------ src/mpid/ch4/src/ch4_init.c | 94 ++------------------------- 8 files changed, 153 insertions(+), 181 deletions(-) delete mode 100644 src/mpid/ch4/src/ch4_csel_container.h diff --git a/src/mpi/coll/include/csel_container.h b/src/mpi/coll/include/csel_container.h index b082ca619a0..f4173b16f69 100644 --- a/src/mpi/coll/include/csel_container.h +++ b/src/mpi/coll/include/csel_container.h @@ -215,6 +215,36 @@ typedef enum { MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_POSIX_mpi_reduce_release_gather, MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_beta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_beta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_gamma, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_delta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_beta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_gamma, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_beta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_gamma, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_delta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_beta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallv_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallw_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_beta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgatherv_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gather_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gatherv_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatter_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatterv_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_block_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_beta, + MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Exscan_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count, } MPII_Csel_container_type_e; diff --git a/src/mpi/coll/src/csel_constants.c b/src/mpi/coll/src/csel_constants.c index cf0fab2b9e1..86b916fd2b8 100644 --- a/src/mpi/coll/src/csel_constants.c +++ b/src/mpi/coll/src/csel_constants.c @@ -447,5 +447,64 @@ const char *Csel_container_type_str[] = { "MPIDI_POSIX_mpi_reduce_release_gather", /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Reduce_impl */ "MPIR_Reduce_impl", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_alpha */ + "MPIDI_Barrier_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_beta */ + "MPIDI_Barrier_intra_composition_beta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_alpha */ + "MPIDI_Bcast_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_beta */ + "MPIDI_Bcast_intra_composition_beta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_gamma */ + "MPIDI_Bcast_intra_composition_gamma", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_delta */ + "MPIDI_Bcast_intra_composition_delta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_alpha */ + "MPIDI_Reduce_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_beta */ + "MPIDI_Reduce_intra_composition_beta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_gamma */ + "MPIDI_Reduce_intra_composition_gamma", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_alpha */ + "MPIDI_Allreduce_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_beta */ + "MPIDI_Allreduce_intra_composition_beta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_gamma */ + "MPIDI_Allreduce_intra_composition_gamma", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_delta */ + "MPIDI_Allreduce_intra_composition_delta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_alpha */ + "MPIDI_Alltoall_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_beta */ + "MPIDI_Alltoall_intra_composition_beta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallv_intra_composition_alpha */ + "MPIDI_Alltoallv_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallw_intra_composition_alpha */ + "MPIDI_Alltoallw_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_alpha */ + "MPIDI_Allgather_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_beta */ + "MPIDI_Allgather_intra_composition_beta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgatherv_intra_composition_alpha */ + "MPIDI_Allgatherv_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gather_intra_composition_alpha */ + "MPIDI_Gather_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gatherv_intra_composition_alpha */ + "MPIDI_Gatherv_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatter_intra_composition_alpha */ + "MPIDI_Scatter_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatterv_intra_composition_alpha */ + "MPIDI_Scatterv_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_intra_composition_alpha */ + "MPIDI_Reduce_scatter_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_block_intra_composition_alpha */ + "MPIDI_Reduce_scatter_block_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_alpha */ + "MPIDI_Scan_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_beta */ + "MPIDI_Scan_intra_composition_beta", + /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Exscan_intra_composition_alpha */ + "MPIDI_Exscan_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count */ "END_OF_MPIR_ALGO" }; diff --git a/src/mpi/coll/src/csel_container.c b/src/mpi/coll/src/csel_container.c index 3978dfca9eb..91488dd8aa2 100644 --- a/src/mpi/coll/src/csel_container.c +++ b/src/mpi/coll/src/csel_container.c @@ -384,6 +384,20 @@ void *MPII_Create_container(struct json_object *obj) if (!strncmp(ckey, "algorithm=", strlen("algorithm="))) { char *str = ckey + strlen("algorithm="); + bool matched = false; + for (int idx = 0; idx < MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count; idx++) { + if (strcmp(str, Csel_container_type_str[idx]) == 0) { + cnt->id = idx; + matched = true; + break; + } + } + if (!matched) { + MPIR_Assert(0); + } + } else if (!strncmp(ckey, "composition=", strlen("composition="))) { + char *str = ckey + strlen("composition="); + bool matched = false; for (int idx = 0; idx < MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count; idx++) { if (strcmp(str, Csel_container_type_str[idx]) == 0) { diff --git a/src/mpid/ch4/include/mpidpre.h b/src/mpid/ch4/include/mpidpre.h index 667751c705a..58d5827a1d7 100644 --- a/src/mpid/ch4/include/mpidpre.h +++ b/src/mpid/ch4/include/mpidpre.h @@ -21,7 +21,6 @@ #include "shmpre.h" #endif #include "uthash.h" -#include "ch4_csel_container.h" #define MPID_TAG_DEV_BITS 0 #define MPID_MAX_BC_SIZE 4096 diff --git a/src/mpid/ch4/src/ch4_coll.h b/src/mpid/ch4/src/ch4_coll.h index c16fceaa9bc..0a45953e943 100644 --- a/src/mpid/ch4/src/ch4_coll.h +++ b/src/mpid/ch4/src/ch4_coll.h @@ -102,7 +102,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Barrier_allcomm_composition_json(MPIR_Comm * comm, int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__BARRIER, @@ -118,10 +118,10 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Barrier_allcomm_composition_json(MPIR_Comm * } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_alpha: mpi_errno = MPIDI_Barrier_intra_composition_alpha(comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_beta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_beta: mpi_errno = MPIDI_Barrier_intra_composition_beta(comm, coll_attr); break; default: @@ -192,7 +192,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Bcast_allcomm_composition_json(void *buffer, .u.bcast.root = root, }; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; if (MPIR_CVAR_COLL_HYBRID_MEMORY) { cnt = MPIR_Csel_search(MPIDI_COMM(comm, csel_comm), coll_sig); @@ -213,19 +213,19 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Bcast_allcomm_composition_json(void *buffer, } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_alpha: mpi_errno = MPIDI_Bcast_intra_composition_alpha(buffer, count, datatype, root, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_beta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_beta: mpi_errno = MPIDI_Bcast_intra_composition_beta(buffer, count, datatype, root, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_gamma: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_gamma: mpi_errno = MPIDI_Bcast_intra_composition_gamma(buffer, count, datatype, root, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_delta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_delta: mpi_errno = MPIDI_Bcast_intra_composition_delta(buffer, count, datatype, root, comm, coll_attr); break; @@ -333,7 +333,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Allreduce_allcomm_composition_json(const void int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; int num_leads = 0, node_comm_size = 0; MPIR_Csel_coll_sig_s coll_sig = { @@ -356,22 +356,22 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Allreduce_allcomm_composition_json(const void } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_alpha: mpi_errno = MPIDI_Allreduce_intra_composition_alpha(sendbuf, recvbuf, count, datatype, op, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_beta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_beta: mpi_errno = MPIDI_Allreduce_intra_composition_beta(sendbuf, recvbuf, count, datatype, op, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_gamma: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_gamma: mpi_errno = MPIDI_Allreduce_intra_composition_gamma(sendbuf, recvbuf, count, datatype, op, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_delta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_delta: if (comm->comm_kind == MPIR_COMM_KIND__INTRACOMM) { MPIDI_Allreduce_fill_multi_leads_info(comm); if (comm->node_comm) @@ -527,7 +527,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Allgather_allcomm_composition_json(const void { int mpi_errno = MPI_SUCCESS; MPI_Aint type_size, data_size; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; if (sendbuf != MPI_IN_PLACE) { MPIR_Datatype_get_size_macro(sendtype, type_size); @@ -560,7 +560,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Allgather_allcomm_composition_json(const void } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_alpha: /* make sure that the algo can be run */ if (comm->comm_kind == MPIR_COMM_KIND__INTRACOMM) MPIDI_Allgather_fill_multi_leads_info(comm); @@ -573,7 +573,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Allgather_allcomm_composition_json(const void recvbuf, recvcount, recvtype, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_beta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_beta: MPII_COLLECTIVE_FALLBACK_CHECK(comm->rank, comm->comm_kind == MPIR_COMM_KIND__INTRACOMM, mpi_errno, "Allgather composition beta cannot be applied.\n"); @@ -683,7 +683,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Allgatherv(const void *sendbuf, MPI_Aint sendc MPI_Datatype recvtype, MPIR_Comm * comm, int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__ALLGATHERV, @@ -711,7 +711,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Allgatherv(const void *sendbuf, MPI_Aint sendc } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgatherv_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgatherv_intra_composition_alpha: mpi_errno = MPIDI_Allgatherv_intra_composition_alpha(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, @@ -736,7 +736,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Scatter(const void *sendbuf, MPI_Aint sendcoun int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__SCATTER, @@ -763,7 +763,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Scatter(const void *sendbuf, MPI_Aint sendcoun } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatter_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatter_intra_composition_alpha: mpi_errno = MPIDI_Scatter_intra_composition_alpha(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, coll_attr); @@ -787,7 +787,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Scatterv(const void *sendbuf, const MPI_Aint * int root, MPIR_Comm * comm, int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__SCATTERV, @@ -815,7 +815,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Scatterv(const void *sendbuf, const MPI_Aint * } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatterv_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatterv_intra_composition_alpha: mpi_errno = MPIDI_Scatterv_intra_composition_alpha(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, @@ -840,7 +840,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Gather(const void *sendbuf, MPI_Aint sendcount int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__GATHER, @@ -868,7 +868,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Gather(const void *sendbuf, MPI_Aint sendcount } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gather_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gather_intra_composition_alpha: mpi_errno = MPIDI_Gather_intra_composition_alpha(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, coll_attr); @@ -893,7 +893,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Gatherv(const void *sendbuf, MPI_Aint sendcoun int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__GATHERV, @@ -921,7 +921,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Gatherv(const void *sendbuf, MPI_Aint sendcoun } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gatherv_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gatherv_intra_composition_alpha: mpi_errno = MPIDI_Gatherv_intra_composition_alpha(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, @@ -978,7 +978,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Alltoall_allcomm_composition_json(const void data_size = recvcount * type_size; } - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__ALLTOALL, @@ -1002,7 +1002,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Alltoall_allcomm_composition_json(const void } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_alpha: if (comm->comm_kind == MPIR_COMM_KIND__INTRACOMM) MPIDI_Alltoall_fill_multi_leads_info(comm); MPII_COLLECTIVE_FALLBACK_CHECK(comm->rank, comm->comm_kind == MPIR_COMM_KIND__INTRACOMM @@ -1015,7 +1015,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Alltoall_allcomm_composition_json(const void coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_beta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_beta: MPII_COLLECTIVE_FALLBACK_CHECK(comm->rank, comm->comm_kind == MPIR_COMM_KIND__INTRACOMM, mpi_errno, "Alltoall composition beta cannot be applied.\n"); @@ -1124,7 +1124,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Alltoallv(const void *sendbuf, const MPI_Aint MPIR_Comm * comm, int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__ALLTOALLV, @@ -1153,7 +1153,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Alltoallv(const void *sendbuf, const MPI_Aint } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallv_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallv_intra_composition_alpha: mpi_errno = MPIDI_Alltoallv_intra_composition_alpha(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, @@ -1180,7 +1180,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Alltoallw(const void *sendbuf, const MPI_Aint int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__ALLTOALLW, @@ -1209,7 +1209,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Alltoallw(const void *sendbuf, const MPI_Aint } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallw_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallw_intra_composition_alpha: mpi_errno = MPIDI_Alltoallw_intra_composition_alpha(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, @@ -1235,7 +1235,7 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Reduce_allcomm_composition_json(const void *s int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__REDUCE, @@ -1258,17 +1258,17 @@ MPL_STATIC_INLINE_PREFIX int MPIDI_Reduce_allcomm_composition_json(const void *s } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_alpha: mpi_errno = MPIDI_Reduce_intra_composition_alpha(sendbuf, recvbuf, count, datatype, op, root, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_beta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_beta: mpi_errno = MPIDI_Reduce_intra_composition_beta(sendbuf, recvbuf, count, datatype, op, root, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_gamma: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_gamma: mpi_errno = MPIDI_Reduce_intra_composition_gamma(sendbuf, recvbuf, count, datatype, op, root, comm, coll_attr); @@ -1350,7 +1350,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Reduce_scatter(const void *sendbuf, void *recv MPI_Op op, MPIR_Comm * comm, int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__REDUCE_SCATTER, @@ -1375,7 +1375,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Reduce_scatter(const void *sendbuf, void *recv } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_intra_composition_alpha: mpi_errno = MPIDI_Reduce_scatter_intra_composition_alpha(sendbuf, recvbuf, recvcounts, datatype, op, comm, coll_attr); @@ -1398,7 +1398,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Reduce_scatter_block(const void *sendbuf, void MPI_Op op, MPIR_Comm * comm, int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__REDUCE_SCATTER_BLOCK, @@ -1424,7 +1424,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Reduce_scatter_block(const void *sendbuf, void } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_block_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_block_intra_composition_alpha: mpi_errno = MPIDI_Reduce_scatter_block_intra_composition_alpha(sendbuf, recvbuf, recvcount, datatype, op, comm, coll_attr); @@ -1447,7 +1447,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Scan(const void *sendbuf, void *recvbuf, MPI_A int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__SCAN, @@ -1471,12 +1471,12 @@ MPL_STATIC_INLINE_PREFIX int MPID_Scan(const void *sendbuf, void *recvbuf, MPI_A } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_alpha: mpi_errno = MPIDI_Scan_intra_composition_alpha(sendbuf, recvbuf, count, datatype, op, comm, coll_attr); break; - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_beta: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_beta: mpi_errno = MPIDI_Scan_intra_composition_beta(sendbuf, recvbuf, count, datatype, op, comm, coll_attr); @@ -1499,7 +1499,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Exscan(const void *sendbuf, void *recvbuf, MPI int coll_attr) { int mpi_errno = MPI_SUCCESS; - const MPIDI_Csel_container_s *cnt = NULL; + const MPII_Csel_container_s *cnt = NULL; MPIR_Csel_coll_sig_s coll_sig = { .coll_type = MPIR_CSEL_COLL_TYPE__EXSCAN, @@ -1523,7 +1523,7 @@ MPL_STATIC_INLINE_PREFIX int MPID_Exscan(const void *sendbuf, void *recvbuf, MPI } switch (cnt->id) { - case MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Exscan_intra_composition_alpha: + case MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Exscan_intra_composition_alpha: mpi_errno = MPIDI_Exscan_intra_composition_alpha(sendbuf, recvbuf, count, datatype, op, comm, coll_attr); diff --git a/src/mpid/ch4/src/ch4_coll_impl.h b/src/mpid/ch4/src/ch4_coll_impl.h index af4fcb1379f..8c7801ae855 100644 --- a/src/mpid/ch4/src/ch4_coll_impl.h +++ b/src/mpid/ch4/src/ch4_coll_impl.h @@ -77,7 +77,6 @@ #ifndef CH4_COLL_IMPL_H_INCLUDED #define CH4_COLL_IMPL_H_INCLUDED -#include "ch4_csel_container.h" #include "ch4_comm.h" #include "algo_common.h" diff --git a/src/mpid/ch4/src/ch4_csel_container.h b/src/mpid/ch4/src/ch4_csel_container.h deleted file mode 100644 index 364c00ece87..00000000000 --- a/src/mpid/ch4/src/ch4_csel_container.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (C) by Argonne National Laboratory - * See COPYRIGHT in top-level directory - */ - -#ifndef CH4_CSEL_CONTAINER_H_INCLUDED -#define CH4_CSEL_CONTAINER_H_INCLUDED - -typedef struct { - enum { - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_alpha = 0, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_beta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_beta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_gamma, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_delta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_beta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_gamma, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_beta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_gamma, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_delta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_beta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallv_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallw_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_beta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgatherv_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gather_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gatherv_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatter_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatterv_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_block_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_alpha, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_beta, - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Exscan_intra_composition_alpha, - } id; -} MPIDI_Csel_container_s; - -#endif /* CH4_CSEL_CONTAINER_H_INCLUDED */ diff --git a/src/mpid/ch4/src/ch4_init.c b/src/mpid/ch4/src/ch4_init.c index c94c573cb1d..060e77885b2 100644 --- a/src/mpid/ch4/src/ch4_init.c +++ b/src/mpid/ch4/src/ch4_init.c @@ -185,92 +185,6 @@ static const char *devcollstr(void) return NULL; } -static void *create_container(struct json_object *obj) -{ - MPIDI_Csel_container_s *cnt = MPL_malloc(sizeof(MPIDI_Csel_container_s), MPL_MEM_COLL); - - json_object_object_foreach(obj, key, val) { - char *ckey = MPL_strdup_no_spaces(key); - - if (!strcmp(ckey, "composition=MPIDI_Barrier_intra_composition_alpha")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Barrier_intra_composition_beta")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Barrier_intra_composition_beta; - else if (!strcmp(ckey, "composition=MPIDI_Bcast_intra_composition_alpha")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Bcast_intra_composition_beta")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_beta; - else if (!strcmp(ckey, "composition=MPIDI_Bcast_intra_composition_gamma")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_gamma; - else if (!strcmp(ckey, "composition=MPIDI_Bcast_intra_composition_delta")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Bcast_intra_composition_delta; - else if (!strcmp(ckey, "composition=MPIDI_Allreduce_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Allreduce_intra_composition_beta")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_beta; - else if (!strcmp(ckey, "composition=MPIDI_Allreduce_intra_composition_gamma")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allreduce_intra_composition_gamma; - else if (!strcmp(ckey, "composition=MPIDI_Reduce_intra_composition_alpha")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Reduce_intra_composition_beta")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_beta; - else if (!strcmp(ckey, "composition=MPIDI_Reduce_intra_composition_gamma")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_intra_composition_gamma; - else if (!strcmp(ckey, "composition=MPIDI_Alltoall_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Alltoall_intra_composition_beta")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoall_intra_composition_beta; - else if (!strcmp(ckey, "composition=MPIDI_Alltoallv_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallv_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Alltoallw_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Alltoallw_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Allgather_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Allgather_intra_composition_beta")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgather_intra_composition_beta; - else if (!strcmp(ckey, "composition=MPIDI_Allgatherv_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Allgatherv_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Gather_intra_composition_alpha")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gather_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Gatherv_intra_composition_alpha")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Gatherv_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Scatter_intra_composition_alpha")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatter_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Scatterv_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scatterv_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Reduce_scatter_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Reduce_scatter_block_intra_composition_alpha")) - cnt->id = - MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Reduce_scatter_block_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Scan_intra_composition_alpha")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_alpha; - else if (!strcmp(ckey, "composition=MPIDI_Scan_intra_composition_beta")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_beta; - else if (!strcmp(ckey, "composition=MPIDI_Exscan_intra_composition_alpha")) - cnt->id = MPIDI_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Exscan_intra_composition_alpha; - else { - fprintf(stderr, "unrecognized key %s\n", ckey); - MPIR_Assert(0); - } - - MPL_free(ckey); - } - - return (void *) cnt; -} - static int choose_netmod(void); static int choose_netmod(void) @@ -561,11 +475,11 @@ int MPID_Init(int requested, int *provided) /* Initialize collective selection */ if (!strcmp(MPIR_CVAR_CH4_COLL_SELECTION_TUNING_JSON_FILE, "")) { mpi_errno = MPIR_Csel_create_from_buf(MPIDI_coll_generic_json, - create_container, &MPIDI_global.csel_root); + MPII_Create_container, &MPIDI_global.csel_root); MPIDI_global.csel_source = "MPIDI_coll_generic_json"; } else { mpi_errno = MPIR_Csel_create_from_file(MPIR_CVAR_CH4_COLL_SELECTION_TUNING_JSON_FILE, - create_container, &MPIDI_global.csel_root); + MPII_Create_container, &MPIDI_global.csel_root); MPIDI_global.csel_source = MPIR_CVAR_CH4_COLL_SELECTION_TUNING_JSON_FILE; } MPIR_ERR_CHECK(mpi_errno); @@ -573,11 +487,11 @@ int MPID_Init(int requested, int *provided) /* Initialize collective selection for gpu */ if (!strcmp(MPIR_CVAR_CH4_COLL_SELECTION_TUNING_JSON_FILE_GPU, "")) { mpi_errno = MPIR_Csel_create_from_buf(MPIDI_coll_generic_json, - create_container, &MPIDI_global.csel_root_gpu); + MPII_Create_container, &MPIDI_global.csel_root_gpu); MPIDI_global.csel_source_gpu = "MPIDI_coll_generic_json"; } else { mpi_errno = MPIR_Csel_create_from_file(MPIR_CVAR_CH4_COLL_SELECTION_TUNING_JSON_FILE_GPU, - create_container, &MPIDI_global.csel_root_gpu); + MPII_Create_container, &MPIDI_global.csel_root_gpu); MPIDI_global.csel_source_gpu = MPIR_CVAR_CH4_COLL_SELECTION_TUNING_JSON_FILE_GPU; } MPIR_ERR_CHECK(mpi_errno); From 85e142ad7d16ff74b84d334ffcb51c1676666219 Mon Sep 17 00:00:00 2001 From: Yanfei Guo Date: Thu, 17 Jul 2025 15:34:01 -0500 Subject: [PATCH 4/6] coll: merge json processing of OFI algorithms Consolidate the OFI coll algorithm enum definition under MPII. The JSON parsing no longer need separate functions for them. --- src/mpi/coll/include/csel_container.h | 11 ++++++++ src/mpi/coll/src/csel_constants.c | 5 ++++ src/mpid/ch4/netmod/ofi/ofi_csel_container.h | 28 -------------------- src/mpid/ch4/netmod/ofi/ofi_init.c | 1 - 4 files changed, 16 insertions(+), 29 deletions(-) delete mode 100644 src/mpid/ch4/netmod/ofi/ofi_csel_container.h diff --git a/src/mpi/coll/include/csel_container.h b/src/mpi/coll/include/csel_container.h index f4173b16f69..9c84b66660e 100644 --- a/src/mpi/coll/include/csel_container.h +++ b/src/mpi/coll/include/csel_container.h @@ -245,6 +245,9 @@ typedef enum { MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Scan_intra_composition_beta, MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Exscan_intra_composition_alpha, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_OFI_Bcast_intra_triggered_tagged, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_OFI_Bcast_intra_triggered_rma, + MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count, } MPII_Csel_container_type_e; @@ -366,6 +369,14 @@ typedef struct { int chunk_size; int recv_pre_posted; } intra_pipelined_tree; + struct { + int k; + int tree_type; + } triggered_tagged; + struct { + int k; + int tree_type; + } triggered_rma; } bcast; struct { struct { diff --git a/src/mpi/coll/src/csel_constants.c b/src/mpi/coll/src/csel_constants.c index 86b916fd2b8..ad892261a4d 100644 --- a/src/mpi/coll/src/csel_constants.c +++ b/src/mpi/coll/src/csel_constants.c @@ -506,5 +506,10 @@ const char *Csel_container_type_str[] = { /* MPII_CSEL_CONTAINER_TYPE__COMPOSITION__MPIDI_Exscan_intra_composition_alpha */ "MPIDI_Exscan_intra_composition_alpha", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_OFI_Bcast_intra_triggered_tagged */ + "MPIDI_OFI_Bcast_intra_triggered_tagged", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_OFI_Bcast_intra_triggered_rma */ + "MPIDI_OFI_Bcast_intra_triggered_rma", + /* MPII_CSEL_CONTAINER_TYPE__ALGORITHM__Algorithm_count */ "END_OF_MPIR_ALGO" }; diff --git a/src/mpid/ch4/netmod/ofi/ofi_csel_container.h b/src/mpid/ch4/netmod/ofi/ofi_csel_container.h deleted file mode 100644 index 9780b9d8424..00000000000 --- a/src/mpid/ch4/netmod/ofi/ofi_csel_container.h +++ /dev/null @@ -1,28 +0,0 @@ -#ifndef OFI_CSEL_CONTAINER_H_INCLUDED -#define OFI_CSEL_CONTAINER_H_INCLUDED - -typedef enum { - MPIDI_OFI_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_OFI_Bcast_intra_triggered_tagged, - MPIDI_OFI_CSEL_CONTAINER_TYPE__ALGORITHM__MPIDI_OFI_Bcast_intra_triggered_rma, - MPIDI_OFI_CSEL_CONTAINER_TYPE__ALGORITHM__MPIR_Bcast_impl, - MPIDI_OFI_Algorithm_count, -} MPIDI_OFI_Csel_container_type_e; - -typedef struct { - MPIDI_OFI_Csel_container_type_e id; - - union { - struct { - struct { - int k; - int tree_type; - } triggered_tagged; - struct { - int k; - int tree_type; - } triggered_rma; - } bcast; - } u; -} MPIDI_OFI_csel_container_s; - -#endif /* OFI_CSEL_CONTAINER_H_INCLUDED */ diff --git a/src/mpid/ch4/netmod/ofi/ofi_init.c b/src/mpid/ch4/netmod/ofi/ofi_init.c index 3aab17f80a0..27264dd4948 100644 --- a/src/mpid/ch4/netmod/ofi/ofi_init.c +++ b/src/mpid/ch4/netmod/ofi/ofi_init.c @@ -8,7 +8,6 @@ #include "ofi_am_impl.h" #include "ofi_noinline.h" #include "mpir_hwtopo.h" -#include "ofi_csel_container.h" #include "ofi_init.h" /* From f29196dc040cef8623ec74a3d284200416aa241d Mon Sep 17 00:00:00 2001 From: Yanfei Guo Date: Sun, 3 Aug 2025 23:05:43 -0500 Subject: [PATCH 5/6] csel: add new env for printing csel report MPIR_CVAR_COLLECTIVE_SELECTION_REPORT controls how MPICH show the collective selection logic during init. It is turned off by default. The user can choose to print the CSEL in tree format or summary format (later commit). --- src/include/mpir_csel.h | 2 + src/mpi/coll/src/coll_impl.c | 1 + src/mpi/coll/src/csel.c | 58 ++++++++++++++++++++++------- src/mpid/ch4/shm/posix/posix_init.c | 3 ++ src/mpid/ch4/src/ch4_init.c | 2 + 5 files changed, 52 insertions(+), 14 deletions(-) diff --git a/src/include/mpir_csel.h b/src/include/mpir_csel.h index 5bf3cc25e35..03b2b3136ca 100644 --- a/src/include/mpir_csel.h +++ b/src/include/mpir_csel.h @@ -217,4 +217,6 @@ int MPIR_Csel_free(void *csel); int MPIR_Csel_prune(void *root_csel, MPIR_Comm * comm_ptr, void **comm_csel); void *MPIR_Csel_search(void *csel, MPIR_Csel_coll_sig_s coll_sig); +void MPIR_Csel_debug_summary(const char *name, void *csel_); + #endif /* MPIR_CSEL_H_INCLUDED */ diff --git a/src/mpi/coll/src/coll_impl.c b/src/mpi/coll/src/coll_impl.c index 41f528301bd..953edf99964 100644 --- a/src/mpi/coll/src/coll_impl.c +++ b/src/mpi/coll/src/coll_impl.c @@ -198,6 +198,7 @@ int MPII_Coll_init(void) MPII_Create_container, &MPIR_Csel_root); MPIR_Csel_source = MPIR_CVAR_COLL_SELECTION_TUNING_JSON_FILE; } + MPIR_Csel_debug_summary(MPIR_Csel_source, MPIR_Csel_root); MPIR_ERR_CHECK(mpi_errno); fn_exit: diff --git a/src/mpi/coll/src/csel.c b/src/mpi/coll/src/csel.c index eb58e599ebb..66c5ac89b26 100644 --- a/src/mpi/coll/src/csel.c +++ b/src/mpi/coll/src/csel.c @@ -12,6 +12,27 @@ #include #include +/* +=== BEGIN_MPI_T_CVAR_INFO_BLOCK === + +cvars: + - name : MPIR_CVAR_COLLECTIVE_SELECTION_REPORT + category : COLLECTIVE + type : enum + default : none + class : none + verbosity : MPI_T_VERBOSITY_USER_BASIC + scope : MPI_T_SCOPE_ALL_EQ + description : |- + Variable to select report type. + none - No print out + summary - Print a summary of each algorithm + tree - Print the collective selection tree + all - Print both tree and summary + +=== END_MPI_T_CVAR_INFO_BLOCK === +*/ + static void validate_tree(csel_node_s * node) { static int coll = -1; @@ -239,21 +260,34 @@ int MPIR_Csel_create_from_buf(const char *json, json_object_put(tree); - if (MPIR_CVAR_DEBUG_SUMMARY && MPIR_Process.rank == 0) { - printf("====================================\n"); - printf("Processed Collective Selection Tree:\n"); - Csel_print_tree(csel->u.root.tree); - printf("==========================================\n"); - printf("Summary of rules per collective algorithm:\n"); - Csel_print_rules(csel->u.root.tree); - - } - fn_exit: *csel_ = csel; return 0; } +void MPIR_Csel_debug_summary(const char *name, void *csel_) +{ + csel_s *csel = (csel_s *) csel_; + if (MPIR_Process.rank != 0) { + return; + } + + if (MPIR_CVAR_COLLECTIVE_SELECTION_REPORT == MPIR_CVAR_COLLECTIVE_SELECTION_REPORT_tree + || MPIR_CVAR_COLLECTIVE_SELECTION_REPORT == MPIR_CVAR_COLLECTIVE_SELECTION_REPORT_all) { + printf("Processed Collective Selection Tree for %s:\n", name); + printf("============================================================\n"); + Csel_print_tree(csel->u.root.tree); + printf("============================================================\n"); + } + if (MPIR_CVAR_COLLECTIVE_SELECTION_REPORT == MPIR_CVAR_COLLECTIVE_SELECTION_REPORT_summary + || MPIR_CVAR_COLLECTIVE_SELECTION_REPORT == MPIR_CVAR_COLLECTIVE_SELECTION_REPORT_all) { + printf("Summary of rules per collective algorithm for %s:\n", name); + printf("============================================================\n"); + Csel_print_rules(csel->u.root.tree); + printf("============================================================\n"); + } +} + int MPIR_Csel_create_from_file(const char *json_file, void *(*create_container) (struct json_object *), void **csel_) { @@ -270,10 +304,6 @@ int MPIR_Csel_create_from_file(const char *json_file, char *json = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); close(fd); - if (MPIR_CVAR_DEBUG_SUMMARY && MPIR_Process.rank == 0) { - printf("Loaded Collective Selection Tree from %s:\n", json_file); - } - MPIR_Csel_create_from_buf(json, create_container, csel_); fn_fail: diff --git a/src/mpid/ch4/shm/posix/posix_init.c b/src/mpid/ch4/shm/posix/posix_init.c index c184b60be26..26781e55b7f 100644 --- a/src/mpid/ch4/shm/posix/posix_init.c +++ b/src/mpid/ch4/shm/posix/posix_init.c @@ -388,6 +388,7 @@ static int posix_coll_init(void) &MPIDI_global.shm.posix.csel_root); MPIDI_global.shm.posix.csel_source = MPIR_CVAR_CH4_POSIX_COLL_SELECTION_TUNING_JSON_FILE; } + MPIR_Csel_debug_summary(MPIDI_global.shm.posix.csel_source, MPIDI_global.shm.posix.csel_root); MPIR_ERR_CHECK(mpi_errno); /* Initialize collective selection for gpu */ @@ -403,6 +404,8 @@ static int posix_coll_init(void) MPIDI_global.shm.posix.csel_source_gpu = MPIR_CVAR_CH4_POSIX_COLL_SELECTION_TUNING_JSON_FILE_GPU; } + MPIR_Csel_debug_summary(MPIDI_global.shm.posix.csel_source_gpu, + MPIDI_global.shm.posix.csel_root_gpu); MPIR_ERR_CHECK(mpi_errno); fn_exit: diff --git a/src/mpid/ch4/src/ch4_init.c b/src/mpid/ch4/src/ch4_init.c index 060e77885b2..1e4d0afec2a 100644 --- a/src/mpid/ch4/src/ch4_init.c +++ b/src/mpid/ch4/src/ch4_init.c @@ -482,6 +482,7 @@ int MPID_Init(int requested, int *provided) MPII_Create_container, &MPIDI_global.csel_root); MPIDI_global.csel_source = MPIR_CVAR_CH4_COLL_SELECTION_TUNING_JSON_FILE; } + MPIR_Csel_debug_summary(MPIDI_global.csel_source, MPIDI_global.csel_root); MPIR_ERR_CHECK(mpi_errno); /* Initialize collective selection for gpu */ @@ -494,6 +495,7 @@ int MPID_Init(int requested, int *provided) MPII_Create_container, &MPIDI_global.csel_root_gpu); MPIDI_global.csel_source_gpu = MPIR_CVAR_CH4_COLL_SELECTION_TUNING_JSON_FILE_GPU; } + MPIR_Csel_debug_summary(MPIDI_global.csel_source_gpu, MPIDI_global.csel_root_gpu); MPIR_ERR_CHECK(mpi_errno); /* Override split_type */ From 395ea2733d944bf30778fbf67b1819a06d9b2db3 Mon Sep 17 00:00:00 2001 From: Yanfei Guo Date: Wed, 6 Aug 2025 00:38:06 -0500 Subject: [PATCH 6/6] maint: update gitignore with generated files --- .gitignore | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.gitignore b/.gitignore index 871ce51cad1..26bd4ed885a 100644 --- a/.gitignore +++ b/.gitignore @@ -426,6 +426,8 @@ Makefile.am-stamp /src/binding/fortran/use_mpi/mpif90type.h /src/binding/fortran/use_mpi/mpi_constants.f90 /src/binding/fortran/use_mpi/mpifnoext.h +/src/binding/fortran/use_mpi/pmpi_base.f90 +/src/binding/fortran/use_mpi/pmpi_base.mod-stamp # generated by src/binding/fortran/use_mpi_f08/buildiface /src/binding/fortran/use_mpi_f08/mpi_f08_compile_constants.f90 @@ -615,6 +617,14 @@ Makefile.am-stamp /src/mpid/ch4/shm/stubshm/shm_inline.h /src/mpid/ch4/shm/stubshm/shm_noinline.h /src/mpid/ch4/shm/stubshm/stubshm_noinline.c +/src/mpid/ch4/shm/posix/eager/include/posix_eager.h +/src/mpid/ch4/shm/posix/eager/iqueue/func_table.c +/src/mpid/ch4/shm/posix/eager/iqueue/iqueue_noinline.h +/src/mpid/ch4/shm/posix/eager/src/posix_eager_impl.c +/src/mpid/ch4/shm/posix/eager/stub/func_table.c +/src/mpid/ch4/shm/posix/eager/stub/stub_inline.h +/src/mpid/ch4/shm/posix/eager/stub/stub_noinline.c +/src/mpid/ch4/shm/posix/eager/stub/stub_noinline.h src/pm/hydra/lib/tools/bootstrap/src/bsci_init.c src/pmi/aclocal.m4