Add MPI_Alltoallv to tuned collectives and add a pairwise implementation of MPI_Alltoallv. However, do not change the default behavior for now. The only way to use new pairwise implementation is via mca parameters.

This commit was SVN r18394.

ompi/mca/coll/tuned/Makefile.am

@@ -32,6 +32,7 @@ sources = \
         coll_tuned_forced.c \
         coll_tuned_allreduce.c \
         coll_tuned_alltoall.c \
+        coll_tuned_alltoallv.c \
         coll_tuned_allgather.c \
         coll_tuned_allgatherv.c \
         coll_tuned_barrier.c \

ompi/mca/coll/tuned/coll_tuned.h

@@ -9,6 +9,7 @@
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
+ * Copyright (c) 2008      Sun Microsystems, Inc.  All rights reserved.
  * $COPYRIGHT$
  * 
  * Additional copyrights may follow
@@ -160,6 +161,11 @@ extern "C" {
     /* AlltoAllV */
     int ompi_coll_tuned_alltoallv_intra_dec_fixed(ALLTOALLV_ARGS);
     int ompi_coll_tuned_alltoallv_intra_dec_dynamic(ALLTOALLV_ARGS);
+    int ompi_coll_tuned_alltoallv_intra_do_forced(ALLTOALLV_ARGS);
+    int ompi_coll_tuned_alltoallv_intra_do_this(ALLTOALLV_ARGS, int algorithm);
+    int ompi_coll_tuned_alltoallv_intra_check_forced_init(coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices);
+    int ompi_coll_tuned_alltoallv_intra_pairwise(ALLTOALLV_ARGS);
+    int ompi_coll_tuned_alltoallv_intra_basic_linear(ALLTOALLV_ARGS);
     int ompi_coll_tuned_alltoallv_inter_dec_fixed(ALLTOALLV_ARGS);
     int ompi_coll_tuned_alltoallv_inter_dec_dynamic(ALLTOALLV_ARGS);
 

ompi/mca/coll/tuned/coll_tuned_alltoallv.c

@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2006 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2008      Sun Microsystems, Inc.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "mpi.h"
+#include "ompi/constants.h"
+#include "ompi/datatype/datatype.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/mca/coll/coll.h"
+#include "ompi/mca/coll/base/coll_tags.h"
+#include "ompi/mca/pml/pml.h"
+#include "ompi/op/op.h"
+#include "coll_tuned.h"
+#include "coll_tuned_topo.h"
+#include "coll_tuned_util.h"
+
+int
+ompi_coll_tuned_alltoallv_intra_pairwise(void *sbuf, int *scounts, int *sdisps,
+                                         struct ompi_datatype_t *sdtype,
+                                         void* rbuf, int *rcounts, int *rdisps,
+                                         struct ompi_datatype_t *rdtype,
+                                         struct ompi_communicator_t *comm,
+                                         struct mca_coll_base_module_1_1_0_t *module)
+{
+    int line = -1, err = 0;
+    int rank, size, step;
+    int sendto, recvfrom;
+    void *psnd, *prcv;
+    ptrdiff_t sext, rext;
+
+    size = ompi_comm_size(comm);
+    rank = ompi_comm_rank(comm);
+
+    OPAL_OUTPUT((ompi_coll_tuned_stream,
+                 "coll:tuned:alltoallv_intra_pairwise rank %d", rank));
+
+    ompi_ddt_type_extent(sdtype, &sext);
+    ompi_ddt_type_extent(rdtype, &rext);
+
+    psnd = ((char *) sbuf) + (sdisps[rank] * sext);
+    prcv = ((char *) rbuf) + (rdisps[rank] * rext);
+
+    if (0 != scounts[rank]) {
+        err = ompi_ddt_sndrcv(psnd, scounts[rank], sdtype,
+                              prcv, rcounts[rank], rdtype);
+        if (MPI_SUCCESS != err) {
+            return err;
+        }
+    }
+
+    /* If only one process, we're done. */
+    if (1 == size) {
+        return MPI_SUCCESS;
+    }
+
+    /* Perform pairwise exchange starting from 1 since local exhange is done */
+    for (step = 1; step < size + 1; step++) {
+
+        /* Determine sender and receiver for this step. */
+        sendto  = (rank + step) % size;
+        recvfrom = (rank + size - step) % size;
+
+        /* Determine sending and receiving locations */
+        psnd = (char*)sbuf + sdisps[sendto] * sext;
+        prcv = (char*)rbuf + rdisps[recvfrom] * rext;
+
+        /* send and receive */
+        err = ompi_coll_tuned_sendrecv( psnd, scounts[sendto], sdtype, sendto, 
+                                        MCA_COLL_BASE_TAG_ALLTOALLV,
+                                        prcv, rcounts[recvfrom], rdtype, recvfrom, 
+                                        MCA_COLL_BASE_TAG_ALLTOALLV,
+                                        comm, MPI_STATUS_IGNORE, rank);
+        if (err != MPI_SUCCESS) { line = __LINE__; goto err_hndl;  }
+    }
+
+    return MPI_SUCCESS;
+ 
+ err_hndl:
+    OPAL_OUTPUT((ompi_coll_tuned_stream,
+                 "%s:%4d\tError occurred %d, rank %2d", __FILE__, line, 
+                 err, rank));
+    return err;
+}
+
+/*  
+ * Linear functions are copied from the basic coll module.  For
+ * some small number of nodes and/or small data sizes they are just as
+ * fast as tuned/tree based segmenting operations and as such may be
+ * selected by the decision functions.  These are copied into this module
+ * due to the way we select modules in V1. i.e. in V2 we will handle this
+ * differently and so will not have to duplicate code.  
+ * GEF Oct05 after asking Jeff.  
+ */
+int
+ompi_coll_tuned_alltoallv_intra_basic_linear(void *sbuf, int *scounts, int *sdisps,
+                                            struct ompi_datatype_t *sdtype,
+                                            void *rbuf, int *rcounts, int *rdisps,
+                                            struct ompi_datatype_t *rdtype,
+                                            struct ompi_communicator_t *comm,
+                                            struct mca_coll_base_module_1_1_0_t *module)
+{
+    int i, size, rank, err;
+    char *psnd, *prcv;
+    int nreqs;
+    ptrdiff_t sext, rext;
+    MPI_Request *preq;
+    mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
+    mca_coll_tuned_comm_t *data = tuned_module->tuned_data;
+
+    OPAL_OUTPUT((ompi_coll_tuned_stream,
+                 "coll:tuned:alltoallv_intra_basic_linear rank %d", rank));
+
+    size = ompi_comm_size(comm);
+    rank = ompi_comm_rank(comm);
+
+    ompi_ddt_type_extent(sdtype, &sext);
+    ompi_ddt_type_extent(rdtype, &rext);
+
+    /* Simple optimization - handle send to self first */
+    psnd = ((char *) sbuf) + (sdisps[rank] * sext);
+    prcv = ((char *) rbuf) + (rdisps[rank] * rext);
+    if (0 != scounts[rank]) {
+        err = ompi_ddt_sndrcv(psnd, scounts[rank], sdtype,
+                              prcv, rcounts[rank], rdtype);
+        if (MPI_SUCCESS != err) {
+            return err;
+        }
+    }
+
+    /* If only one process, we're done. */
+    if (1 == size) {
+        return MPI_SUCCESS;
+    }
+
+    /* Now, initiate all send/recv to/from others. */
+    nreqs = 0;
+    preq = data->mcct_reqs;
+
+    /* Post all receives first */
+    for (i = 0; i < size; ++i) {
+        if (i == rank || 0 == rcounts[i]) {
+            continue;
+        }
+
+        prcv = ((char *) rbuf) + (rdisps[i] * rext);
+        err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtype,
+                                      i, MCA_COLL_BASE_TAG_ALLTOALLV, comm,
+                                      preq++));
+        ++nreqs;
+        if (MPI_SUCCESS != err) {
+            ompi_coll_tuned_free_reqs(data->mcct_reqs, nreqs);
+            return err;
+        }
+    }
+
+    /* Now post all sends */
+    for (i = 0; i < size; ++i) {
+        if (i == rank || 0 == scounts[i]) {
+            continue;
+        }
+
+        psnd = ((char *) sbuf) + (sdisps[i] * sext);
+        err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtype,
+                                      i, MCA_COLL_BASE_TAG_ALLTOALLV,
+                                      MCA_PML_BASE_SEND_STANDARD, comm,
+                                      preq++));
+        ++nreqs;
+        if (MPI_SUCCESS != err) {
+            ompi_coll_tuned_free_reqs(data->mcct_reqs, nreqs);
+            return err;
+        }
+    }
+
+    /* Start your engines.  This will never return an error. */
+    MCA_PML_CALL(start(nreqs, data->mcct_reqs));
+
+    /* Wait for them all.  If there's an error, note that we don't care
+     * what the error was -- just that there *was* an error.  The PML
+     * will finish all requests, even if one or more of them fail.
+     * i.e., by the end of this call, all the requests are free-able.
+     * So free them anyway -- even if there was an error, and return the
+     * error after we free everything. */
+    err = ompi_request_wait_all(nreqs, data->mcct_reqs,
+                                MPI_STATUSES_IGNORE);
+
+    /* Free the requests. */
+    ompi_coll_tuned_free_reqs(data->mcct_reqs, nreqs);
+
+    return err;
+}
+
+/* 
+ * 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_alltoallv_intra_check_forced_init(coll_tuned_force_algorithm_mca_param_indices_t
+                                                      *mca_param_indices)
+{
+    int max_alg = 2, requested_alg, max_requests;
+
+    ompi_coll_tuned_forced_max_algorithms[ALLTOALLV] = max_alg;
+
+    mca_base_param_reg_int (&mca_coll_tuned_component.super.collm_version,
+                            "alltoallv_algorithm_count",
+                            "Number of alltoallv algorithms available",
+                            false, true, max_alg, NULL);
+
+    mca_param_indices->algorithm_param_index
+        = mca_base_param_reg_int(&mca_coll_tuned_component.super.collm_version,
+                                 "alltoallv_algorithm",
+                                 "Which alltoallv algorithm is used. "
+                                 "Can be locked down to choice of: 0 ignore, "
+                                 "1 basic linear, 2 pairwise.",
+                                 false, false, 0, NULL);
+    mca_base_param_lookup_int(mca_param_indices->algorithm_param_index, &(requested_alg));
+    if (requested_alg > max_alg) {
+        if (0 == ompi_comm_rank( MPI_COMM_WORLD)) {
+            opal_output(0, "Alltoallv algorithm #%d is not available (range [0..%d]). "
+                        "Switching back to ignore(0)\n",
+                        requested_alg, max_alg );
+        }
+        mca_base_param_set_int(mca_param_indices->algorithm_param_index, 0);
+    }
+    
+    return (MPI_SUCCESS);
+}
+
+
+
+int ompi_coll_tuned_alltoallv_intra_do_forced(void *sbuf, int *scounts, int *sdisps, 
+                                              struct ompi_datatype_t *sdtype,
+                                              void* rbuf, int *rcounts, int *rdisps, 
+                                              struct ompi_datatype_t *rdtype,
+                                              struct ompi_communicator_t *comm,
+                                              struct mca_coll_base_module_1_1_0_t *module)
+{
+    mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
+    mca_coll_tuned_comm_t *data = tuned_module->tuned_data;
+
+    OPAL_OUTPUT((ompi_coll_tuned_stream,
+                 "coll:tuned:alltoallv_intra_do_forced selected algorithm %d",
+                 data->user_forced[ALLTOALLV].algorithm));
+
+    switch (data->user_forced[ALLTOALLV].algorithm) {
+    case (0):   
+        return ompi_coll_tuned_alltoallv_intra_dec_fixed(sbuf, scounts, sdisps, sdtype, 
+                                                         rbuf, rcounts, rdisps, rdtype,
+                                                         comm, module);
+    case (1):
+        return ompi_coll_tuned_alltoallv_intra_basic_linear(sbuf, scounts, sdisps, sdtype,
+                                                            rbuf, rcounts, rdisps, rdtype,      
+                                                            comm, module);
+    case (2): 
+        return ompi_coll_tuned_alltoallv_intra_pairwise(sbuf, scounts, sdisps, sdtype,
+                                                        rbuf, rcounts, rdisps, rdtype,
+                                                        comm, module);
+    default:
+        OPAL_OUTPUT((ompi_coll_tuned_stream,
+                     "coll:tuned:alltoallv_intra_do_forced attempt to "
+                     "select algorithm %d when only 0-%d is valid.", 
+                     data->user_forced[ALLTOALLV].algorithm,
+                     ompi_coll_tuned_forced_max_algorithms[ALLTOALLV]));
+        return (MPI_ERR_ARG);
+    }
+}
+
+/* If the user selects dynamic rules and specifies the algorithm to
+ * use, then this function is called.  */
+int ompi_coll_tuned_alltoallv_intra_do_this(void *sbuf, int *scounts, int *sdisps,
+                                            struct ompi_datatype_t *sdtype,
+                                            void* rbuf, int *rcounts, int *rdisps,
+                                            struct ompi_datatype_t *rdtype,
+                                            struct ompi_communicator_t *comm,
+                                            struct mca_coll_base_module_1_1_0_t *module,
+                                            int algorithm)
+{
+    OPAL_OUTPUT((ompi_coll_tuned_stream,
+                 "coll:tuned:alltoallv_intra_do_this selected algorithm %d ",
+                 algorithm));
+
+    switch (algorithm) {
+    case (0):
+        return ompi_coll_tuned_alltoallv_intra_dec_fixed(sbuf, scounts, sdisps, sdtype,
+                                                        rbuf, rcounts, rdisps, rdtype,
+                                                        comm, module);
+    case (1):
+        return ompi_coll_tuned_alltoallv_intra_basic_linear(sbuf, scounts, sdisps, sdtype,
+                                                           rbuf, rcounts, rdisps, rdtype,
+                                                           comm, module);
+    case (2):
+        return ompi_coll_tuned_alltoallv_intra_pairwise(sbuf, scounts, sdisps, sdtype,
+                                                       rbuf, rcounts, rdisps, rdtype,
+                                                       comm, module);
+    default:
+        OPAL_OUTPUT((ompi_coll_tuned_stream,
+                     "coll:tuned:alltoall_intra_do_this attempt to select "
+                     "algorithm %d when only 0-%d is valid.", 
+                     algorithm, ompi_coll_tuned_forced_max_algorithms[ALLTOALLV]));
+        return (MPI_ERR_ARG);
+    }
+}

ompi/mca/coll/tuned/coll_tuned_component.c

@@ -9,6 +9,7 @@
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
+ * Copyright (c) 2008      Sun Microsystems, Inc.  All rights reserved.
  * $COPYRIGHT$
  * 
  * Additional copyrights may follow
@@ -185,7 +186,7 @@ static int tuned_open(void)
         ompi_coll_tuned_alltoall_intra_check_forced_init(&ompi_coll_tuned_forced_params[ALLTOALL]);
         ompi_coll_tuned_allgather_intra_check_forced_init(&ompi_coll_tuned_forced_params[ALLGATHER]);
         ompi_coll_tuned_allgatherv_intra_check_forced_init(&ompi_coll_tuned_forced_params[ALLGATHERV]);
-        /*ompi_coll_tuned_alltoallv_intra_check_forced_init(&ompi_coll_tuned_forced_params[ALLTOALLV]); */
+        ompi_coll_tuned_alltoallv_intra_check_forced_init(&ompi_coll_tuned_forced_params[ALLTOALLV]);
         ompi_coll_tuned_barrier_intra_check_forced_init(&ompi_coll_tuned_forced_params[BARRIER]);
         ompi_coll_tuned_bcast_intra_check_forced_init(&ompi_coll_tuned_forced_params[BCAST]);
         ompi_coll_tuned_reduce_intra_check_forced_init(&ompi_coll_tuned_forced_params[REDUCE]);

ompi/mca/coll/tuned/coll_tuned_decision_dynamic.c

@@ -9,6 +9,7 @@
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
+ * Copyright (c) 2008      Sun Microsystems, Inc.  All rights reserved.
  * $COPYRIGHT$
  * 
  * Additional copyrights may follow
@@ -146,6 +147,44 @@ int ompi_coll_tuned_alltoall_intra_dec_dynamic(void *sbuf, int scount,
 						     comm, module);
 }
 
+/*
+ *    Function:   - selects alltoallv algorithm to use
+ *    Accepts:    - same arguments as MPI_Alltoallv()
+ *    Returns:    - MPI_SUCCESS or error code
+ */
+
+int ompi_coll_tuned_alltoallv_intra_dec_dynamic(void *sbuf, int *scounts, int *sdisps,
+                                                struct ompi_datatype_t *sdtype,
+                                                void* rbuf, int *rcounts, int *rdisps,
+                                                struct ompi_datatype_t *rdtype, 
+                                                struct ompi_communicator_t *comm,
+                                                struct mca_coll_base_module_1_1_0_t *module)
+{
+    mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module;
+    mca_coll_tuned_comm_t *data = tuned_module->tuned_data;
+
+    OPAL_OUTPUT((ompi_coll_tuned_stream, "ompi_coll_tuned_alltoallv_intra_dec_dynamic"));
+
+    /* 
+     * BEGIN - File Based Rules
+     *
+     * Here is where we would check to see if we have some file based
+     * rules.  Currently, we do not, so move on to seeing if the user
+     * specified a specific algorithm.  If not, then use the fixed
+     * decision code to decide.
+     *
+     * END - File Based Rules
+     */
+    if (data->user_forced[ALLTOALLV].algorithm) {
+        return ompi_coll_tuned_alltoallv_intra_do_forced(sbuf, scounts, sdisps, sdtype,
+                                                         rbuf, rcounts, rdisps, rdtype,
+                                                         comm, module);
+    }
+    return ompi_coll_tuned_alltoallv_intra_dec_fixed(sbuf, scounts, sdisps, sdtype,
+                                                     rbuf, rcounts, rdisps, rdtype,
+                                                     comm, module);
+}
+
 /*
  *    barrier_intra_dec 
  *

ompi/mca/coll/tuned/coll_tuned_decision_fixed.c

@@ -9,6 +9,7 @@
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
+ * Copyright (c) 2008      Sun Microsystems, Inc.  All rights reserved.
  * $COPYRIGHT$
  * 
  * Additional copyrights may follow
@@ -153,6 +154,24 @@ int ompi_coll_tuned_alltoall_intra_dec_fixed(void *sbuf, int scount,
 #endif
 }
 
+/*
+ *      Function:       - selects alltoallv algorithm to use
+ *      Accepts:        - same arguments as MPI_Alltoallv()
+ *      Returns:        - MPI_SUCCESS or error code
+ */
+int ompi_coll_tuned_alltoallv_intra_dec_fixed(void *sbuf, int *scounts, int *sdisps,
+                                              struct ompi_datatype_t *sdtype,
+                                              void *rbuf, int *rcounts, int *rdisps,
+                                              struct ompi_datatype_t *rdtype,
+                                              struct ompi_communicator_t *comm,
+                                              struct mca_coll_base_module_1_1_0_t *module)
+{
+    /* For starters, just keep the original algorithm. */
+    return ompi_coll_tuned_alltoallv_intra_basic_linear(sbuf, scounts, sdisps, sdtype, 
+                                                        rbuf, rcounts, rdisps,rdtype,
+                                                        comm, module);
+}
+
 
 /*
  *	barrier_intra_dec 

ompi/mca/coll/tuned/coll_tuned_module.c

@@ -9,6 +9,7 @@
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
+ * Copyright (c) 2008      Sun Microsystems, Inc.  All rights reserved.
  * $COPYRIGHT$
  * 
  * Additional copyrights may follow
@@ -104,7 +105,7 @@ ompi_coll_tuned_comm_query(struct ompi_communicator_t *comm, int *priority)
 	tuned_module->super.coll_allgatherv = ompi_coll_tuned_allgatherv_intra_dec_dynamic;
 	tuned_module->super.coll_allreduce  = ompi_coll_tuned_allreduce_intra_dec_dynamic;
 	tuned_module->super.coll_alltoall   = ompi_coll_tuned_alltoall_intra_dec_dynamic;
-	tuned_module->super.coll_alltoallv  = NULL;
+	tuned_module->super.coll_alltoallv  = ompi_coll_tuned_alltoallv_intra_dec_dynamic;
 	tuned_module->super.coll_alltoallw  = NULL;
 	tuned_module->super.coll_barrier    = ompi_coll_tuned_barrier_intra_dec_dynamic;
 	tuned_module->super.coll_bcast      = ompi_coll_tuned_bcast_intra_dec_dynamic;
@@ -124,7 +125,7 @@ ompi_coll_tuned_comm_query(struct ompi_communicator_t *comm, int *priority)
 	tuned_module->super.coll_allgatherv = ompi_coll_tuned_allgatherv_intra_dec_fixed;
 	tuned_module->super.coll_allreduce  = ompi_coll_tuned_allreduce_intra_dec_fixed;
 	tuned_module->super.coll_alltoall   = ompi_coll_tuned_alltoall_intra_dec_fixed;
-	tuned_module->super.coll_alltoallv  = NULL;
+	tuned_module->super.coll_alltoallv  = ompi_coll_tuned_alltoallv_intra_dec_fixed;
 	tuned_module->super.coll_alltoallw  = NULL;
 	tuned_module->super.coll_barrier    = ompi_coll_tuned_barrier_intra_dec_fixed;
 	tuned_module->super.coll_bcast      = ompi_coll_tuned_bcast_intra_dec_fixed;
@@ -250,7 +251,7 @@ tuned_module_enable(struct mca_coll_base_module_1_1_0_t *module,
         ompi_coll_tuned_forced_getvalues         (ompi_coll_tuned_forced_params[ALLTOALL],  &(data->user_forced[ALLTOALL]));
         ompi_coll_tuned_forced_getvalues         (ompi_coll_tuned_forced_params[ALLGATHER],  &(data->user_forced[ALLGATHER]));
         ompi_coll_tuned_forced_getvalues         (ompi_coll_tuned_forced_params[ALLGATHERV],  &(data->user_forced[ALLGATHERV]));
-        /*         ompi_coll_tuned_forced_getvalues (ompi_coll_tuned_forced_params[ALLTOALLV], &(data->user_forced[ALLTOALLV])); */
+        ompi_coll_tuned_forced_getvalues         (ompi_coll_tuned_forced_params[ALLTOALLV], &(data->user_forced[ALLTOALLV]));
         ompi_coll_tuned_forced_getvalues_barrier (ompi_coll_tuned_forced_params[BARRIER],   &(data->user_forced[BARRIER]));
         ompi_coll_tuned_forced_getvalues         (ompi_coll_tuned_forced_params[BCAST],     &(data->user_forced[BCAST]));
         ompi_coll_tuned_forced_getvalues         (ompi_coll_tuned_forced_params[REDUCE],    &(data->user_forced[REDUCE]));