coll/csel: load json as named subtrees

Load src/mpi/coll/coll_selection.json as named subtrees.

Add MPIR_Coll_run_tree which runs the selection on a subtree.

Replace MPIR_Coll_composition_auto with MPIR_Coll_json, and replace
MPIR_Coll_auto with MPIR_Coll_run_tree(csel_tree_auto, coll_sig).

csel_tree_auto will fallback to csel_tree_main if it is not defined in
the json file. But similarly, we can easily introduce more predefined
subtree later, e.g. bcast-intra-auto etc.

In CVAR selection, the "auto" should be default and value should be 0.
Thus it should automatically fallthrough and run on csel_tree_main.

Author: hzhou

maint/gen_coll.py

@@ -366,7 +366,8 @@ def dump_cvar_cases(name, commkind):
 
         dump_open("switch (cvar_val) {")
         G.out.append("case MPIR_CVAR_%s_%s_ALGORITHM_auto:" % (name.upper(), commkind.upper()))
-        G.out.append("    return %s__MPIR_Coll_auto;" % (algo_id_prefix))
+        G.out.append("    MPIR_Assert(0); /* auto cvar_val should be 0 and shouldn't be called here */")
+        G.out.append("    return %s;" % algo_id_END())
         if not name.startswith("i"): # blocking
             G.out.append("case MPIR_CVAR_%s_%s_ALGORITHM_nb:" % (name.upper(), commkind.upper()))
             G.out.append("    return %s__MPIR_Coll_nb;" % (algo_id_prefix))
@@ -381,6 +382,7 @@ def dump_cvar_cases(name, commkind):
     add_prototype(decl)
     G.out.append(decl)
     dump_open("{")
+    G.out.append("MPIR_Assert(cvar_val > 0);")
     dump_open("switch (coll_type) {")
     for coll in G.coll_names:
         for commkind in ("intra", "inter"):
@@ -612,7 +614,7 @@ def dump_coll_impl(name, blocking_type):
 
     # Call csel
     G.out.append("")
-    G.out.append("mpi_errno = MPIR_Coll_composition_auto(&coll_sig);")
+    G.out.append("mpi_errno = MPIR_Coll_json(&coll_sig);")
     G.out.append("MPIR_ERR_CHECK(mpi_errno);")
     G.out.append("")
 

maint/json_gen.sh

@@ -33,5 +33,4 @@ cat > $cfile<<EOF
 EOF
 
 # create specific json buffers
-create_json_buf src/mpi/coll/coll_composition.json MPII_coll_composition_json
 create_json_buf src/mpi/coll/coll_selection.json   MPII_coll_selection_json

src/mpi/coll/coll_algorithms.txt

@@ -70,7 +70,6 @@ conditions:
 
 # ----
 general:
-    MPIR_Coll_auto
     MPIR_Coll_nb
 
 # ----

src/mpi/coll/coll_composition.json

@@ -33,11 +33,13 @@ extern const char **MPIR_Coll_type_names;
 extern const char **MPIR_Coll_algo_names;
 extern const char **MPIR_Csel_condition_names;
 
-int MPIR_Csel_create_from_file(const char *json_file, void **csel);
-int MPIR_Csel_create_from_buf(const char *json, void **csel);
-int MPIR_Csel_free(void *csel);
+int MPIR_Csel_load_file(const char *json_file);
+int MPIR_Csel_load_buf(const char *json_str);
+int MPIR_Csel_free(void);
+MPIR_Csel_node_s *MPIR_Csel_get_tree(const char *name);
 MPII_Csel_container_s *MPIR_Csel_search(void *csel, MPIR_Csel_coll_sig_s * coll_sig);
 void MPIR_Csel_print_tree(MPIR_Csel_node_s * node, int level);
+int MPIR_Coll_run_tree(MPIR_Csel_node_s * tree, MPIR_Csel_coll_sig_s * coll_sig);
 
 MPL_STATIC_INLINE_PREFIX int MPIR_Csel_comm_size(MPIR_Csel_coll_sig_s * coll_sig)
 {

src/mpi/coll/include/coll_csel.h

@@ -39,7 +39,6 @@ extern MPIR_Tree_type_t MPIR_Allreduce_tree_type;
 extern MPIR_Tree_type_t MPIR_Ireduce_tree_type;
 extern MPIR_Tree_type_t MPIR_Ibcast_tree_type;
 extern MPIR_Tree_type_t MPIR_Bcast_tree_type;
-extern char MPII_coll_composition_json[];
 extern char MPII_coll_selection_json[];
 
 MPIR_Tree_type_t get_tree_type_from_string(const char *tree_str);
@@ -58,10 +57,7 @@ int MPIR_Coll_safe_to_block(void);
 
 int MPII_Coll_finalize(void);
 
-/* NOTE: MPIR_Coll_auto is one of the composition container functions. However,
- *       MPIR_Coll_composition_auto is a gate function, thus does not take "cnt" parameter. */
-int MPIR_Coll_composition_auto(MPIR_Csel_coll_sig_s * coll_sig);
-int MPIR_Coll_auto(MPIR_Csel_coll_sig_s * coll_sig, MPII_Csel_container_s * cnt);
+int MPIR_Coll_json(MPIR_Csel_coll_sig_s * coll_sig);
 
 #define MPII_GENTRAN_CREATE_SCHED_P() \
     do { \

src/mpi/coll/include/coll_impl.h

@@ -40,16 +40,6 @@ categories :
       description : >-
         Defines the location of tuning file that selects basic collective algorithms.
 
-    - name        : MPIR_CVAR_COLL_COMPOSITION_JSON_FILE
-      category    : COLLECTIVE
-      type        : string
-      default     : ""
-      class       : none
-      verbosity   : MPI_T_VERBOSITY_USER_BASIC
-      scope       : MPI_T_SCOPE_ALL_EQ
-      description : >-
-        Defines the location of tuning file that selects composition collective algorithms.
-
     - name        : MPIR_CVAR_HIERARCHY_DUMP
       category    : COLLECTIVE
       type        : boolean
@@ -106,9 +96,8 @@ MPIR_Tree_type_t MPIR_Ireduce_tree_type = MPIR_TREE_TYPE_KARY;
 void *MPIR_Csel_root = NULL;
 const char *MPIR_Csel_source;
 
-/* TODO: remove the old MPIR_Csel_root etc. */
-void *MPIR_Csel_composition = NULL;
-void *MPIR_Csel_selection = NULL;
+MPIR_Csel_node_s *csel_tree_main;
+MPIR_Csel_node_s *csel_tree_auto;
 
 /* table of all collective algorithms */
 MPIR_Coll_algo_fn *MPIR_Coll_algo_table;
@@ -167,16 +156,6 @@ int get_ccl_from_string(const char *ccl_str)
     return ccl;
 }
 
-#define LOAD_CSEL_JSON(csel_var, cvar_name, builtin_str) \
-   do { \
-        if (!strcmp(cvar_name, "")) { \
-            mpi_errno = MPIR_Csel_create_from_buf(builtin_str, &csel_var); \
-        } else { \
-            mpi_errno = MPIR_Csel_create_from_file(cvar_name, &csel_var); \
-        } \
-        MPIR_ERR_CHECK(mpi_errno); \
-   } while (0)
-
 int MPII_Coll_init(void)
 {
     int mpi_errno = MPI_SUCCESS;
@@ -225,10 +204,21 @@ int MPII_Coll_init(void)
     MPII_Csel_init_condition_names();
 
     /* initialize selection tree */
-    LOAD_CSEL_JSON(MPIR_Csel_composition,
-                   MPIR_CVAR_COLL_COMPOSITION_JSON_FILE, MPII_coll_composition_json);
-    LOAD_CSEL_JSON(MPIR_Csel_selection,
-                   MPIR_CVAR_COLL_SELECTION_JSON_FILE, MPII_coll_selection_json);
+    mpi_errno = MPIR_Csel_load_buf(MPII_coll_selection_json);
+    MPIR_ERR_CHECK(mpi_errno);
+
+    if (strcmp(MPIR_CVAR_COLL_SELECTION_JSON_FILE, "") != 0) {
+        mpi_errno = MPIR_Csel_load_file(MPIR_CVAR_COLL_SELECTION_JSON_FILE);
+        MPIR_ERR_CHECK(mpi_errno);
+    }
+
+    csel_tree_main = MPIR_Csel_get_tree("main");
+    MPIR_Assert(csel_tree_main);
+
+    csel_tree_auto = MPIR_Csel_get_tree("auto");
+    if (!csel_tree_auto) {
+        csel_tree_auto = csel_tree_main;
+    }
 
   fn_exit:
     return mpi_errno;
@@ -250,10 +240,7 @@ int MPII_Coll_finalize(void)
     mpi_errno = MPII_TSP_finalize();
     MPIR_ERR_CHECK(mpi_errno);
 
-    mpi_errno = MPIR_Csel_free(MPIR_Csel_composition);
-    MPIR_ERR_CHECK(mpi_errno);
-
-    mpi_errno = MPIR_Csel_free(MPIR_Csel_selection);
+    mpi_errno = MPIR_Csel_free();
     MPIR_ERR_CHECK(mpi_errno);
 
     MPL_free(MPIR_Coll_algo_table);
@@ -262,6 +249,9 @@ int MPII_Coll_finalize(void)
     MPL_free(MPIR_Coll_type_names);
     MPL_free(MPIR_Csel_condition_names);
 
+    csel_tree_main = NULL;
+    csel_tree_auto = NULL;
+
   fn_exit:
     return mpi_errno;
   fn_fail:
@@ -408,13 +398,11 @@ void MPIR_Coll_host_buffer_persist_set(void *host_sendbuf, void *host_recvbuf, v
     }
 }
 
-int MPIR_Coll_composition_auto(MPIR_Csel_coll_sig_s * coll_sig)
+int MPIR_Coll_run_tree(MPIR_Csel_node_s * tree, MPIR_Csel_coll_sig_s * coll_sig)
 {
     int mpi_errno = MPI_SUCCESS;
 
-    /* TODO: need a mechanism in coll_sig so we can assert and prevent a dead recursion loop */
-
-    MPII_Csel_container_s *cnt = MPIR_Csel_search(MPIR_Csel_composition, coll_sig);
+    MPII_Csel_container_s *cnt = MPIR_Csel_search(tree, coll_sig);
     MPIR_ERR_CHKANDJUMP(!cnt, mpi_errno, MPI_ERR_OTHER, "**csel_noresult");
 
     mpi_errno = MPIR_Coll_algo_table[cnt->id] (coll_sig, cnt);
@@ -426,7 +414,7 @@ int MPIR_Coll_composition_auto(MPIR_Csel_coll_sig_s * coll_sig)
     goto fn_exit;
 }
 
-int MPIR_Coll_auto(MPIR_Csel_coll_sig_s * coll_sig, MPII_Csel_container_s * me)
+int MPIR_Coll_json(MPIR_Csel_coll_sig_s * coll_sig)
 {
     int mpi_errno = MPI_SUCCESS;
 
@@ -448,13 +436,7 @@ int MPIR_Coll_auto(MPIR_Csel_coll_sig_s * coll_sig, MPII_Csel_container_s * me)
         }
     }
 
-    /* Search an algorithm by Csel */
-    MPII_Csel_container_s *cnt = MPIR_Csel_search(MPIR_Csel_selection, coll_sig);
-    MPIR_ERR_CHKANDJUMP(!cnt, mpi_errno, MPI_ERR_OTHER, "**csel_noresult");
-
-    /* TODO: assert the selected algorithm is not a composition algorithm */
-
-    mpi_errno = MPIR_Coll_algo_table[cnt->id] (coll_sig, cnt);
+    mpi_errno = MPIR_Coll_run_tree(csel_tree_main, coll_sig);
     MPIR_ERR_CHECK(mpi_errno);
 
   fn_exit:
@@ -472,7 +454,7 @@ int MPIR_Coll_nb(MPIR_Csel_coll_sig_s * coll_sig, MPII_Csel_container_s * me)
     MPIR_Assert(coll_sig->coll_type % 2 == 0);
     coll_sig->coll_type += 1;
 
-    mpi_errno = MPIR_Coll_auto(coll_sig, NULL);
+    mpi_errno = MPIR_Coll_run_tree(csel_tree_auto, coll_sig);
     MPIR_ERR_CHECK(mpi_errno);
 
     MPIR_Request *req;

src/mpi/coll/src/coll_impl.c

@@ -34,6 +34,7 @@ UT_array *csel_subtrees = NULL;
 int csel_main_idx = -1;
 
 static int csel_name_to_idx(const char *name);
+static MPIR_Csel_node_s *csel_get_tree_by_idx(int idx);
 static void add_named_tree(const char *name, struct json_object *obj);
 static void replace_named_tree(int idx, struct json_object *obj);
 static int parse_named_trees(void);
@@ -142,12 +143,23 @@ static MPIR_Csel_node_s *parse_json_tree(struct json_object *obj)
 /* parse the json_object assuming it is a list of "name=xxx": subtree.
  * Otherwise, parse it as a single tree and set the name to "main".
  */
+static void csel_subtree_dtor(void *item)
+{
+    struct csel_subtree *p = item;
+    MPIR_Assert(p->json_obj == NULL);
+    if (p->node) {
+        free_tree(p->node);
+        p->node = NULL;
+    }
+}
+
 static int parse_json_names(struct json_object *obj)
 {
     int mpi_errno = MPI_SUCCESS;
 
     if (!csel_subtrees) {
-        static UT_icd csel_subtree_icd = { sizeof(struct csel_subtree), NULL, NULL, NULL };
+        static UT_icd csel_subtree_icd =
+            { sizeof(struct csel_subtree), NULL, NULL, csel_subtree_dtor };
         utarray_new(csel_subtrees, &csel_subtree_icd, MPL_MEM_COLL);
     }
 
@@ -185,13 +197,12 @@ static int parse_json_names(struct json_object *obj)
     return mpi_errno;
 }
 
-int MPIR_Csel_create_from_buf(const char *json, void **csel_)
+int MPIR_Csel_load_buf(const char *json_str)
 {
     int mpi_errno = MPI_SUCCESS;
-    MPIR_Csel_node_s *csel_root = NULL;
 
     struct json_object *tree;
-    tree = json_tokener_parse(json);
+    tree = json_tokener_parse(json_str);
     if (tree == NULL)
         goto fn_exit;
 
@@ -200,15 +211,10 @@ int MPIR_Csel_create_from_buf(const char *json, void **csel_)
     json_object_put(tree);
 
   fn_exit:
-    if (0 && MPIR_Process.rank == 0) {
-        printf("====\n");
-        MPIR_Csel_print_tree(csel_root, 0);
-    }
-    *csel_ = csel_root;
     return mpi_errno;
 }
 
-int MPIR_Csel_create_from_file(const char *json_file, void **csel_)
+int MPIR_Csel_load_file(const char *json_file)
 {
     int mpi_errno = MPI_SUCCESS;
 
@@ -223,19 +229,19 @@ int MPIR_Csel_create_from_file(const char *json_file, void **csel_)
     char *json = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
     close(fd);
 
-    mpi_errno = MPIR_Csel_create_from_buf(json, csel_);
+    mpi_errno = MPIR_Csel_load_buf(json);
 
   fn_fail:
     return mpi_errno;
 }
 
-int MPIR_Csel_free(void *csel_root)
+int MPIR_Csel_free(void)
 {
     int mpi_errno = MPI_SUCCESS;
 
-    if (csel_root) {
-        free_tree(csel_root);
-    }
+    utarray_clear(csel_subtrees);
+    utarray_free(csel_subtrees);
+    csel_subtrees = NULL;
 
     return mpi_errno;
 }
@@ -246,6 +252,13 @@ MPII_Csel_container_s *MPIR_Csel_search(void *csel_, MPIR_Csel_coll_sig_s * coll
     MPIR_Csel_node_s *node = csel_;
     while (node) {
         switch (node->type) {
+            case CSEL_NODE_TYPE__OPERATOR__CALL:
+                MPIR_Csel_node_s * tree = csel_get_tree_by_idx(node->u.call.idx);
+                if (!tree) {
+                    goto fn_fail;
+                }
+                return MPIR_Csel_search(tree, coll_sig);
+
             case CSEL_NODE_TYPE__OPERATOR__COLLECTIVE:
                 if (node->u.collective.coll_type == coll_sig->coll_type)
                     node = node->success;
@@ -267,10 +280,20 @@ MPII_Csel_container_s *MPIR_Csel_search(void *csel_, MPIR_Csel_coll_sig_s * coll
         }
     }
 
+  fn_fail:
     MPIR_Assert(0 && "MPIR_Csel_search failed to find an algorithm");
     return NULL;
 }
 
+MPIR_Csel_node_s *MPIR_Csel_get_tree(const char *name)
+{
+    int idx = csel_name_to_idx(name);
+    if (idx >= 0) {
+        return csel_get_tree_by_idx(idx);
+    }
+    return NULL;
+}
+
 /* -- internal static routines -- */
 
 static void free_tree(MPIR_Csel_node_s * node)
@@ -335,6 +358,14 @@ static int csel_name_to_idx(const char *name)
     }
 }
 
+static MPIR_Csel_node_s *csel_get_tree_by_idx(int idx)
+{
+    struct csel_subtree *p = (void *) utarray_eltptr(csel_subtrees, idx);
+    MPIR_Assert(p);
+    MPIR_Assert(p->node);
+    return p->node;
+}
+
 static void add_named_tree(const char *name, struct json_object *obj)
 {
     struct csel_subtree item = { NULL, obj };