coll/tuned: add recursive doubling algo for [ex]scan

Signed-off-by: Gilles Gouaillardet <gilles@rist.or.jp>

ompi/mca/coll/tuned/Makefile.am

@@ -11,6 +11,8 @@
 #                         All rights reserved.
 # Copyright (c) 2010      Cisco Systems, Inc.  All rights reserved.
 # Copyright (c) 2017      IBM Corporation.  All rights reserved.
+# Copyright (c) 2018      Research Organization for Information Science
+#                         and Technology (RIST).  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -38,7 +40,9 @@ sources = \
         coll_tuned_reduce_decision.c \
         coll_tuned_bcast_decision.c \
         coll_tuned_reduce_scatter_decision.c \
-        coll_tuned_scatter_decision.c
+        coll_tuned_scatter_decision.c \
+        coll_tuned_exscan_decision.c \
+        coll_tuned_scan_decision.c
 
 # Make the output library in this directory, and name it either
 # mca_<type>_<name>.la (for DSO builds) or libmca_<type>_<name>.la

ompi/mca/coll/tuned/coll_tuned.h

@@ -3,8 +3,8 @@
  * Copyright (c) 2004-2015 The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
- * Copyright (c) 2015      Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2015-2018 Research Organization for Information Science
+ *                         and Technology (RIST).  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -156,6 +156,18 @@ int ompi_coll_tuned_scatter_intra_dec_dynamic(SCATTER_ARGS);
 int ompi_coll_tuned_scatter_intra_do_this(SCATTER_ARGS, int algorithm, int faninout, int segsize);
 int ompi_coll_tuned_scatter_intra_check_forced_init (coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices);
 
+/* Exscan */
+int ompi_coll_tuned_exscan_intra_dec_fixed(EXSCAN_ARGS);
+int ompi_coll_tuned_exscan_intra_dec_dynamic(EXSCAN_ARGS);
+int ompi_coll_tuned_exscan_intra_do_this(EXSCAN_ARGS, int algorithm);
+int ompi_coll_tuned_exscan_intra_check_forced_init (coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices);
+
+/* Scan */
+int ompi_coll_tuned_scan_intra_dec_fixed(SCAN_ARGS);
+int ompi_coll_tuned_scan_intra_dec_dynamic(SCAN_ARGS);
+int ompi_coll_tuned_scan_intra_do_this(SCAN_ARGS, int algorithm);
+int ompi_coll_tuned_scan_intra_check_forced_init (coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices);
+
 int mca_coll_tuned_ft_event(int state);
 
 struct mca_coll_tuned_component_t {

ompi/mca/coll/tuned/coll_tuned_component.c

@@ -14,7 +14,7 @@
  * Copyright (c) 2008      Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
  *                         reserved.
- * Copyright (c) 2015      Research Organization for Information Science
+ * Copyright (c) 2015-2018 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * $COPYRIGHT$
  *
@@ -189,6 +189,8 @@ static int tuned_register(void)
     ompi_coll_tuned_reduce_scatter_intra_check_forced_init(&ompi_coll_tuned_forced_params[REDUCESCATTER]);
     ompi_coll_tuned_gather_intra_check_forced_init(&ompi_coll_tuned_forced_params[GATHER]);
     ompi_coll_tuned_scatter_intra_check_forced_init(&ompi_coll_tuned_forced_params[SCATTER]);
+    ompi_coll_tuned_exscan_intra_check_forced_init(&ompi_coll_tuned_forced_params[EXSCAN]);
+    ompi_coll_tuned_scan_intra_check_forced_init(&ompi_coll_tuned_forced_params[SCAN]);
 
     return OMPI_SUCCESS;
 }

ompi/mca/coll/tuned/coll_tuned_decision_dynamic.c

@@ -10,7 +10,7 @@
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
  * Copyright (c) 2008      Sun Microsystems, Inc.  All rights reserved.
- * Copyright (c) 2015      Research Organization for Information Science
+ * Copyright (c) 2015-2018 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * $COPYRIGHT$
  *
@@ -610,3 +610,89 @@ int ompi_coll_tuned_scatter_intra_dec_dynamic(const void *sbuf, int scount,
                                                     rbuf, rcount, rdtype,
                                                     root, comm, module);
 }
+
+int ompi_coll_tuned_exscan_intra_dec_dynamic(const void *sbuf, void* rbuf, int count,
+                                              struct ompi_datatype_t *dtype,
+                                              struct ompi_op_t *op,
+                                              struct ompi_communicator_t *comm,
+                                              mca_coll_base_module_t *module)
+{
+    mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
+
+    OPAL_OUTPUT((ompi_coll_tuned_stream,
+                 "ompi_coll_tuned_exscan_intra_dec_dynamic"));
+
+    /**
+     * check to see if we have some filebased rules.
+     */
+    if (tuned_module->com_rules[EXSCAN]) {
+        int comsize, alg, faninout, segsize, max_requests;
+        size_t dsize;
+
+        comsize = ompi_comm_size(comm);
+        ompi_datatype_type_size (dtype, &dsize);
+        dsize *= comsize;
+
+        alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[EXSCAN],
+                                                        dsize, &faninout, &segsize, &max_requests);
+
+        if (alg) {
+            /* we have found a valid choice from the file based rules for this message size */
+            return ompi_coll_tuned_exscan_intra_do_this (sbuf, rbuf, count, dtype,
+                                                         op, comm, module,
+                                                         alg);
+        } /* found a method */
+    } /*end if any com rules to check */
+
+    if (tuned_module->user_forced[EXSCAN].algorithm) {
+        return ompi_coll_tuned_exscan_intra_do_this(sbuf, rbuf, count, dtype,
+                                                    op, comm, module,
+                                                    tuned_module->user_forced[EXSCAN].algorithm);
+    }
+
+    return ompi_coll_base_exscan_intra_linear(sbuf, rbuf, count, dtype,
+                                              op, comm, module);
+}
+
+int ompi_coll_tuned_scan_intra_dec_dynamic(const void *sbuf, void* rbuf, int count,
+                                           struct ompi_datatype_t *dtype,
+                                           struct ompi_op_t *op,
+                                           struct ompi_communicator_t *comm,
+                                           mca_coll_base_module_t *module)
+{
+    mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
+
+    OPAL_OUTPUT((ompi_coll_tuned_stream,
+                 "ompi_coll_tuned_scan_intra_dec_dynamic"));
+
+    /**
+     * check to see if we have some filebased rules.
+     */
+    if (tuned_module->com_rules[SCAN]) {
+        int comsize, alg, faninout, segsize, max_requests;
+        size_t dsize;
+
+        comsize = ompi_comm_size(comm);
+        ompi_datatype_type_size (dtype, &dsize);
+        dsize *= comsize;
+
+        alg = ompi_coll_tuned_get_target_method_params (tuned_module->com_rules[SCAN],
+                                                        dsize, &faninout, &segsize, &max_requests);
+
+        if (alg) {
+            /* we have found a valid choice from the file based rules for this message size */
+            return ompi_coll_tuned_scan_intra_do_this (sbuf, rbuf, count, dtype,
+                                                       op, comm, module,
+                                                       alg);
+        } /* found a method */
+    } /*end if any com rules to check */
+
+    if (tuned_module->user_forced[SCAN].algorithm) {
+        return ompi_coll_tuned_scan_intra_do_this(sbuf, rbuf, count, dtype,
+                                                  op, comm, module,
+                                                  tuned_module->user_forced[EXSCAN].algorithm);
+    }
+
+    return ompi_coll_base_scan_intra_linear(sbuf, rbuf, count, dtype,
+                                            op, comm, module);
+}

ompi/mca/coll/tuned/coll_tuned_exscan_decision.c

@@ -0,0 +1,104 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2018      Research Organization for Information Science
+ *                         and Technology (RIST).  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "mpi.h"
+#include "ompi/constants.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/mca/coll/coll.h"
+#include "ompi/mca/coll/base/coll_base_topo.h"
+#include "ompi/mca/coll/base/coll_tags.h"
+#include "ompi/mca/pml/pml.h"
+#include "ompi/op/op.h"
+#include "coll_tuned.h"
+
+/* exscan algorithm variables */
+static int coll_tuned_exscan_forced_algorithm = 0;
+
+/* valid values for coll_tuned_exscan_forced_algorithm */
+static mca_base_var_enum_value_t exscan_algorithms[] = {
+    {0, "ignore"},
+    {1, "linear"},
+    {2, "recursive_doubling"},
+    {0, NULL}
+};
+
+/**
+ * The following are used by dynamic and forced rules
+ *
+ * publish details of each algorithm and if its forced/fixed/locked in
+ * as you add methods/algorithms you must update this and the query/map routines
+ *
+ * this routine is called by the component only
+ * this makes sure that the mca parameters are set to their initial values and
+ * perms module does not call this they call the forced_getvalues routine
+ * instead.
+ */
+
+int ompi_coll_tuned_exscan_intra_check_forced_init (coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices)
+{
+    mca_base_var_enum_t*new_enum;
+    int cnt;
+
+    for( cnt = 0; NULL != exscan_algorithms[cnt].string; cnt++ );
+    ompi_coll_tuned_forced_max_algorithms[EXSCAN] = cnt;
+
+    (void) mca_base_component_var_register(&mca_coll_tuned_component.super.collm_version,
+                                           "exscan_algorithm_count",
+                                           "Number of exscan algorithms available",
+                                           MCA_BASE_VAR_TYPE_INT, NULL, 0,
+                                           MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
+                                           OPAL_INFO_LVL_5,
+                                           MCA_BASE_VAR_SCOPE_CONSTANT,
+                                           &ompi_coll_tuned_forced_max_algorithms[EXSCAN]);
+
+    /* MPI_T: This variable should eventually be bound to a communicator */
+    coll_tuned_exscan_forced_algorithm = 0;
+    (void) mca_base_var_enum_create("coll_tuned_exscan_algorithms", exscan_algorithms, &new_enum);
+    mca_param_indices->algorithm_param_index =
+        mca_base_component_var_register(&mca_coll_tuned_component.super.collm_version,
+                                        "exscan_algorithm",
+                                        "Which exscan algorithm is used. Can be locked down to choice of: 0 ignore, 1 linear, 2 recursive_doubling",
+                                        MCA_BASE_VAR_TYPE_INT, new_enum, 0, MCA_BASE_VAR_FLAG_SETTABLE,
+                                        OPAL_INFO_LVL_5,
+                                        MCA_BASE_VAR_SCOPE_ALL,
+                                        &coll_tuned_exscan_forced_algorithm);
+    OBJ_RELEASE(new_enum);
+    if (mca_param_indices->algorithm_param_index < 0) {
+        return mca_param_indices->algorithm_param_index;
+    }
+
+    return (MPI_SUCCESS);
+}
+
+int ompi_coll_tuned_exscan_intra_do_this(const void *sbuf, void* rbuf, int count,
+                                         struct ompi_datatype_t *dtype,
+                                         struct ompi_op_t *op,
+                                         struct ompi_communicator_t *comm,
+                                         mca_coll_base_module_t *module,
+                                         int algorithm)
+{
+    OPAL_OUTPUT((ompi_coll_tuned_stream,"coll:tuned:exscan_intra_do_this selected algorithm %d",
+                 algorithm));
+
+    switch (algorithm) {
+    case (0):
+    case (1):  return ompi_coll_base_exscan_intra_linear(sbuf, rbuf, count, dtype,
+                                                         op, comm, module);
+    case (2):  return ompi_coll_base_exscan_intra_recursivedoubling(sbuf, rbuf, count, dtype,
+                                                                    op, comm, module);
+    } /* switch */
+    OPAL_OUTPUT((ompi_coll_tuned_stream,"coll:tuned:exscan_intra_do_this attempt to select algorithm %d when only 0-%d is valid?",
+                 algorithm, ompi_coll_tuned_forced_max_algorithms[EXSCAN]));
+    return (MPI_ERR_ARG);
+}

ompi/mca/coll/tuned/coll_tuned_module.c

@@ -11,6 +11,8 @@
  *                         All rights reserved.
  * Copyright (c) 2008      Sun Microsystems, Inc.  All rights reserved.
  * Copyright (c) 2016      Intel, Inc.  All rights reserved.
+ * Copyright (c) 2018      Research Organization for Information Science
+ *                         and Technology (RIST).  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -229,7 +231,7 @@ tuned_module_enable( mca_coll_base_module_t *module,
         COLL_TUNED_EXECUTE_IF_DYNAMIC(tuned_module, BCAST,
                                       tuned_module->super.coll_bcast      = ompi_coll_tuned_bcast_intra_dec_dynamic);
         COLL_TUNED_EXECUTE_IF_DYNAMIC(tuned_module, EXSCAN,
-                                      tuned_module->super.coll_exscan     = NULL);
+                                      tuned_module->super.coll_exscan     = ompi_coll_tuned_exscan_intra_dec_dynamic);
         COLL_TUNED_EXECUTE_IF_DYNAMIC(tuned_module, GATHER,
                                       tuned_module->super.coll_gather     = ompi_coll_tuned_gather_intra_dec_dynamic);
         COLL_TUNED_EXECUTE_IF_DYNAMIC(tuned_module, GATHERV,
@@ -239,7 +241,7 @@ tuned_module_enable( mca_coll_base_module_t *module,
         COLL_TUNED_EXECUTE_IF_DYNAMIC(tuned_module, REDUCESCATTER,
                                       tuned_module->super.coll_reduce_scatter = ompi_coll_tuned_reduce_scatter_intra_dec_dynamic);
         COLL_TUNED_EXECUTE_IF_DYNAMIC(tuned_module, SCAN,
-                                      tuned_module->super.coll_scan       = NULL);
+                                      tuned_module->super.coll_scan       = ompi_coll_tuned_scan_intra_dec_dynamic);
         COLL_TUNED_EXECUTE_IF_DYNAMIC(tuned_module, SCATTER,
                                       tuned_module->super.coll_scatter    = ompi_coll_tuned_scatter_intra_dec_dynamic);
         COLL_TUNED_EXECUTE_IF_DYNAMIC(tuned_module, SCATTERV,

ompi/mca/coll/tuned/coll_tuned_scan_decision.c

@@ -0,0 +1,104 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2018      Research Organization for Information Science
+ *                         and Technology (RIST).  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "mpi.h"
+#include "ompi/constants.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/mca/coll/coll.h"
+#include "ompi/mca/coll/base/coll_base_topo.h"
+#include "ompi/mca/coll/base/coll_tags.h"
+#include "ompi/mca/pml/pml.h"
+#include "ompi/op/op.h"
+#include "coll_tuned.h"
+
+/* scan algorithm variables */
+static int coll_tuned_scan_forced_algorithm = 0;
+
+/* valid values for coll_tuned_scan_forced_algorithm */
+static mca_base_var_enum_value_t scan_algorithms[] = {
+    {0, "ignore"},
+    {1, "linear"},
+    {2, "recursive_doubling"},
+    {0, NULL}
+};
+
+/**
+ * The following are used by dynamic and forced rules
+ *
+ * publish details of each algorithm and if its forced/fixed/locked in
+ * as you add methods/algorithms you must update this and the query/map routines
+ *
+ * this routine is called by the component only
+ * this makes sure that the mca parameters are set to their initial values and
+ * perms module does not call this they call the forced_getvalues routine
+ * instead.
+ */
+
+int ompi_coll_tuned_scan_intra_check_forced_init (coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices)
+{
+    mca_base_var_enum_t*new_enum;
+    int cnt;
+
+    for( cnt = 0; NULL != scan_algorithms[cnt].string; cnt++ );
+    ompi_coll_tuned_forced_max_algorithms[SCAN] = cnt;
+
+    (void) mca_base_component_var_register(&mca_coll_tuned_component.super.collm_version,
+                                           "scan_algorithm_count",
+                                           "Number of scan algorithms available",
+                                           MCA_BASE_VAR_TYPE_INT, NULL, 0,
+                                           MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
+                                           OPAL_INFO_LVL_5,
+                                           MCA_BASE_VAR_SCOPE_CONSTANT,
+                                           &ompi_coll_tuned_forced_max_algorithms[SCAN]);
+
+    /* MPI_T: This variable should eventually be bound to a communicator */
+    coll_tuned_scan_forced_algorithm = 0;
+    (void) mca_base_var_enum_create("coll_tuned_scan_algorithms", scan_algorithms, &new_enum);
+    mca_param_indices->algorithm_param_index =
+        mca_base_component_var_register(&mca_coll_tuned_component.super.collm_version,
+                                        "scan_algorithm",
+                                        "Which scan algorithm is used. Can be locked down to choice of: 0 ignore, 1 linear, 2 recursive_doubling",
+                                        MCA_BASE_VAR_TYPE_INT, new_enum, 0, MCA_BASE_VAR_FLAG_SETTABLE,
+                                        OPAL_INFO_LVL_5,
+                                        MCA_BASE_VAR_SCOPE_ALL,
+                                        &coll_tuned_scan_forced_algorithm);
+    OBJ_RELEASE(new_enum);
+    if (mca_param_indices->algorithm_param_index < 0) {
+        return mca_param_indices->algorithm_param_index;
+    }
+
+    return (MPI_SUCCESS);
+}
+
+int ompi_coll_tuned_scan_intra_do_this(const void *sbuf, void* rbuf, int count,
+                                         struct ompi_datatype_t *dtype,
+                                         struct ompi_op_t *op,
+                                         struct ompi_communicator_t *comm,
+                                         mca_coll_base_module_t *module,
+                                         int algorithm)
+{
+    OPAL_OUTPUT((ompi_coll_tuned_stream,"coll:tuned:scan_intra_do_this selected algorithm %d",
+                 algorithm));
+
+    switch (algorithm) {
+    case (0):
+    case (1):  return ompi_coll_base_scan_intra_linear(sbuf, rbuf, count, dtype,
+                                                       op, comm, module);
+    case (2):  return ompi_coll_base_scan_intra_recursivedoubling(sbuf, rbuf, count, dtype,
+                                                                  op, comm, module);
+    } /* switch */
+    OPAL_OUTPUT((ompi_coll_tuned_stream,"coll:tuned:scan_intra_do_this attempt to select algorithm %d when only 0-%d is valid?",
+                 algorithm, ompi_coll_tuned_forced_max_algorithms[SCAN]));
+    return (MPI_ERR_ARG);
+}