added binomial tree based Gather alogrithm, passed IBM and Intel tests
This commit was SVN r13835.
Этот коммит содержится в:
Li-Ta Lo
родитель
b2bb8d7535
Коммит
c5d8c221b0
@ -36,6 +36,7 @@ sources = \
|
||||
coll_tuned_barrier.c \
|
||||
coll_tuned_bcast.c \
|
||||
coll_tuned_reduce.c \
|
||||
coll_tuned_gather.c \
|
||||
coll_tuned_component.c \
|
||||
coll_tuned_module.c
|
||||
|
||||
|
||||
@ -206,6 +206,11 @@ extern int ompi_coll_tuned_forced_max_algorithms[COLLCOUNT];
|
||||
/* Gather */
|
||||
int ompi_coll_tuned_gather_intra_dec_fixed(GATHER_ARGS);
|
||||
int ompi_coll_tuned_gather_intra_dec_dynamic(GATHER_ARGS);
|
||||
int ompi_coll_tuned_gather_intra_do_forced(GATHER_ARGS);
|
||||
int ompi_coll_tuned_gather_intra_do_this(GATHER_ARGS, int algorithm, int faninout, int segsize);
|
||||
int ompi_coll_tuned_gather_intra_check_forced_init (coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices);
|
||||
int ompi_coll_tuned_gather_intra_basic_linear(GATHER_ARGS);
|
||||
int ompi_coll_tuned_gather_intra_binomial(GATHER_ARGS);
|
||||
int ompi_coll_tuned_gather_inter_dec_fixed(GATHER_ARGS);
|
||||
int ompi_coll_tuned_gather_inter_dec_dynamic(GATHER_ARGS);
|
||||
|
||||
@ -329,6 +334,10 @@ struct mca_coll_base_comm_t {
|
||||
ompi_coll_tree_t *cached_bmtree;
|
||||
int cached_bmtree_root;
|
||||
|
||||
/* binomial tree */
|
||||
ompi_coll_tree_t *cached_in_order_bmtree;
|
||||
int cached_in_order_bmtree_root;
|
||||
|
||||
/* chained tree (fanout followed by pipelines) */
|
||||
ompi_coll_tree_t *cached_chain;
|
||||
int cached_chain_root;
|
||||
@ -387,6 +396,19 @@ do {
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define COLL_TUNED_UPDATE_IN_ORDER_BMTREE( OMPI_COMM, ROOT ) \
|
||||
do { \
|
||||
mca_coll_base_comm_t* coll_comm = (OMPI_COMM)->c_coll_selected_data; \
|
||||
if( !( (coll_comm->cached_in_order_bmtree) \
|
||||
&& (coll_comm->cached_in_order_bmtree_root == (ROOT)) ) ) { \
|
||||
if( coll_comm->cached_in_order_bmtree ) { /* destroy previous binomial if defined */ \
|
||||
ompi_coll_tuned_topo_destroy_tree( &(coll_comm->cached_in_order_bmtree) ); \
|
||||
} \
|
||||
coll_comm->cached_in_order_bmtree = ompi_coll_tuned_topo_build_in_order_bmtree( (OMPI_COMM), (ROOT) ); \
|
||||
coll_comm->cached_in_order_bmtree_root = (ROOT); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define COLL_TUNED_UPDATE_PIPELINE( OMPI_COMM, ROOT ) \
|
||||
do { \
|
||||
mca_coll_base_comm_t* coll_comm = (OMPI_COMM)->c_coll_selected_data; \
|
||||
|
||||
@ -191,6 +191,7 @@ static int tuned_open(void)
|
||||
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_coll_tuned_gather_intra_check_forced_init(&ompi_coll_tuned_forced_params[GATHER]);
|
||||
}
|
||||
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream, "coll:tuned:component_open: done!"));
|
||||
|
||||
@ -301,3 +301,23 @@ int ompi_coll_tuned_allgather_intra_dec_dynamic(void *sbuf, int scount,
|
||||
comm);
|
||||
}
|
||||
|
||||
int ompi_coll_tuned_gather_intra_dec_dynamic(void *sbuf, int scount,
|
||||
struct ompi_datatype_t *sdtype,
|
||||
void* rbuf, int rcount,
|
||||
struct ompi_datatype_t *rdtype,
|
||||
int root, struct ompi_communicator_t *comm)
|
||||
{
|
||||
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"ompi_coll_tuned_gather_intra_dec_dynamic"));
|
||||
|
||||
if (comm->c_coll_selected_data->user_forced[GATHER].algorithm) {
|
||||
return ompi_coll_tuned_gather_intra_do_forced (sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
}
|
||||
|
||||
return ompi_coll_tuned_gather_intra_dec_fixed (sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
}
|
||||
|
||||
@ -496,3 +496,24 @@ int ompi_coll_tuned_allgather_intra_dec_fixed(void *sbuf, int scount,
|
||||
rbuf, rcount, rdtype, comm);
|
||||
#endif /* defined(USE_MPICH2_DECISION) */
|
||||
}
|
||||
/*
|
||||
* gather_intra_dec
|
||||
*
|
||||
* Function: - seletects gather algorithm to use
|
||||
* Accepts: - same arguments as MPI_Gather()
|
||||
* Returns: - MPI_SUCCESS or error code, passed from corresponding
|
||||
* internal allgather function.
|
||||
*/
|
||||
|
||||
int ompi_coll_tuned_gather_intra_dec_fixed(void *sbuf, int scount,
|
||||
struct ompi_datatype_t *sdtype,
|
||||
void* rbuf, int rcount,
|
||||
struct ompi_datatype_t *rdtype,
|
||||
int root, struct ompi_communicator_t *comm)
|
||||
{
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"ompi_coll_tuned_gather_intra_dec_fixed"));
|
||||
return ompi_coll_tuned_gather_intra_basic_linear (sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
}
|
||||
|
||||
404
ompi/mca/coll/tuned/coll_tuned_gather.c
Обычный файл
404
ompi/mca/coll/tuned/coll_tuned_gather.c
Обычный файл
@ -0,0 +1,404 @@
|
||||
/*
|
||||
* 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$
|
||||
*
|
||||
* 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_gather_intra_binomial(void *sbuf, int scount,
|
||||
struct ompi_datatype_t *sdtype,
|
||||
void *rbuf, int rcount,
|
||||
struct ompi_datatype_t *rdtype,
|
||||
int root, struct ompi_communicator_t *comm)
|
||||
{
|
||||
int line = -1;
|
||||
int i;
|
||||
int rank;
|
||||
int vrank;
|
||||
int size;
|
||||
int total_recv = 0;
|
||||
char *ptmp = NULL;
|
||||
char *tempbuf = NULL;
|
||||
int err;
|
||||
ompi_coll_tree_t* bmtree;
|
||||
MPI_Status status;
|
||||
MPI_Aint sextent, slb, strue_lb, strue_extent;
|
||||
MPI_Aint rextent, rlb, rtrue_lb, rtrue_extent;
|
||||
|
||||
size = ompi_comm_size(comm);
|
||||
rank = ompi_comm_rank(comm);
|
||||
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"ompi_coll_tuned_gather_intra_binomial rank %d", rank));
|
||||
|
||||
/* create the binomial tree */
|
||||
COLL_TUNED_UPDATE_IN_ORDER_BMTREE( comm, root );
|
||||
bmtree = comm->c_coll_selected_data->cached_in_order_bmtree;
|
||||
|
||||
ompi_ddt_get_extent(sdtype, &slb, &sextent);
|
||||
ompi_ddt_get_true_extent(sdtype, &strue_lb, &strue_extent);
|
||||
ompi_ddt_get_extent(rdtype, &rlb, &rextent);
|
||||
ompi_ddt_get_true_extent(rdtype, &rtrue_lb, &rtrue_extent);
|
||||
|
||||
vrank = (rank - root + size) % size;
|
||||
|
||||
if (rank == root) {
|
||||
if (0 == root){
|
||||
/* root on 0, just use the recv buffer */
|
||||
ptmp = rbuf;
|
||||
if (sbuf != MPI_IN_PLACE) {
|
||||
err = ompi_ddt_sndrcv(sbuf, scount, sdtype,
|
||||
ptmp, rcount, rdtype);
|
||||
if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
|
||||
}
|
||||
} else {
|
||||
/* root is not on 0, allocate temp buffer for recv,
|
||||
* rotate data at the end */
|
||||
tempbuf = malloc(rtrue_extent + (rcount*size - 1) * rextent);
|
||||
if (NULL == tempbuf) {
|
||||
err= OMPI_ERR_OUT_OF_RESOURCE; line = __LINE__; goto err_hndl;
|
||||
}
|
||||
|
||||
ptmp = tempbuf - rlb;
|
||||
if (sbuf != MPI_IN_PLACE) {
|
||||
/* copy from sbuf to temp buffer */
|
||||
err = ompi_ddt_sndrcv(sbuf, scount, sdtype,
|
||||
ptmp, rcount, rdtype);
|
||||
if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
|
||||
} else {
|
||||
/* copy from rbuf to temp buffer */
|
||||
err = ompi_ddt_copy_content_same_ddt(rdtype, rcount, ptmp,
|
||||
(char *) rbuf + rank*rextent*rcount);
|
||||
if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
|
||||
}
|
||||
}
|
||||
total_recv = rcount;
|
||||
} else if (!(vrank % 2)) {
|
||||
/* other non-leaf nodes, allocate temp buffer for data received from
|
||||
* children, the most we need is half of the total data elements due
|
||||
* to the property of binimoal tree */
|
||||
tempbuf = malloc(strue_extent + (scount*size - 1) * sextent);
|
||||
if (NULL == tempbuf) {
|
||||
err= OMPI_ERR_OUT_OF_RESOURCE; line = __LINE__; goto err_hndl;
|
||||
}
|
||||
|
||||
ptmp = tempbuf - slb;
|
||||
/* local copy to tempbuf */
|
||||
err = ompi_ddt_sndrcv(sbuf, scount, sdtype,
|
||||
ptmp, scount, sdtype);
|
||||
if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
|
||||
|
||||
/* use sdtype,scount as rdtype,rdcount since they are ignored on
|
||||
* non-root procs */
|
||||
rdtype = sdtype;
|
||||
rcount = scount;
|
||||
rextent = sextent;
|
||||
total_recv = rcount;
|
||||
} else {
|
||||
/* leaf nodes, no temp buffer needed, use sdtype,scount as
|
||||
* rdtype,rdcount since they are ignored on non-root procs */
|
||||
ptmp = sbuf;
|
||||
total_recv = scount;
|
||||
}
|
||||
|
||||
if (!(vrank % 2)) {
|
||||
/* all non-leaf nodes recv from children */
|
||||
for (i = 0; i < bmtree->tree_nextsize; i++) {
|
||||
int cur_count = 0;
|
||||
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"ompi_coll_tuned_gather_intra_binomial rank %d recv %d ",
|
||||
rank, bmtree->tree_next[i]));
|
||||
|
||||
err = MCA_PML_CALL(recv(ptmp + total_recv*rextent, rcount*size-total_recv, rdtype,
|
||||
bmtree->tree_next[i], MCA_COLL_BASE_TAG_GATHER,
|
||||
comm, &status));
|
||||
if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
|
||||
|
||||
/* the number of elements actually received may be smaller than the count
|
||||
* passed to recv when comm_size is not power of 2 */
|
||||
MPI_Get_count(&status, rdtype, &cur_count);
|
||||
total_recv += cur_count;
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"ompi_coll_tuned_gather_intra_binomial received %d total %d\n",
|
||||
cur_count, total_recv));
|
||||
}
|
||||
}
|
||||
|
||||
if (rank != root) {
|
||||
/* all nodes except root send to parents */
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"ompi_coll_tuned_gather_intra_binomial rank %d send %d count %d\n",
|
||||
rank, bmtree->tree_prev, total_recv));
|
||||
|
||||
err = MCA_PML_CALL(send(ptmp, total_recv, sdtype,
|
||||
bmtree->tree_prev,
|
||||
MCA_COLL_BASE_TAG_GATHER,
|
||||
MCA_PML_BASE_SEND_STANDARD, comm));
|
||||
if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
|
||||
}
|
||||
|
||||
if (rank == root) {
|
||||
if (root != 0) {
|
||||
/* rotate received data on root if root != 0 */
|
||||
err = ompi_ddt_copy_content_same_ddt(rdtype, rcount*(size - root),
|
||||
(char *) rbuf + rextent*root*rcount, ptmp);
|
||||
if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
|
||||
|
||||
|
||||
err = ompi_ddt_copy_content_same_ddt(rdtype, rcount*root,
|
||||
rbuf, ptmp + rextent*rcount*(size-root));
|
||||
if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
|
||||
|
||||
free(tempbuf);
|
||||
}
|
||||
} else if (!(vrank % 2)) {
|
||||
/* other non-leaf nodes */
|
||||
free(tempbuf);
|
||||
}
|
||||
return MPI_SUCCESS;
|
||||
|
||||
err_hndl:
|
||||
if (NULL != tempbuf)
|
||||
free(tempbuf);
|
||||
|
||||
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
|
||||
* they do not segment the message and are simple implementations
|
||||
* but 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.
|
||||
* JPG following the examples from other coll_tuned implementations. Dec06.
|
||||
*/
|
||||
|
||||
/* copied function (with appropriate renaming) starts here */
|
||||
/*
|
||||
* gather_intra
|
||||
*
|
||||
* Function: - basic gather operation
|
||||
* Accepts: - same arguments as MPI_Gather()
|
||||
* Returns: - MPI_SUCCESS or error code
|
||||
*/
|
||||
int
|
||||
ompi_coll_tuned_gather_intra_basic_linear(void *sbuf, int scount,
|
||||
struct ompi_datatype_t *sdtype,
|
||||
void *rbuf, int rcount,
|
||||
struct ompi_datatype_t *rdtype,
|
||||
int root, struct ompi_communicator_t *comm)
|
||||
{
|
||||
int i;
|
||||
int err;
|
||||
int rank;
|
||||
int size;
|
||||
char *ptmp;
|
||||
MPI_Aint incr;
|
||||
MPI_Aint extent;
|
||||
MPI_Aint lb;
|
||||
|
||||
size = ompi_comm_size(comm);
|
||||
rank = ompi_comm_rank(comm);
|
||||
|
||||
/* Everyone but root sends data and returns. */
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"ompi_coll_tuned_gather_intra_basic_linear rank %d", rank));
|
||||
|
||||
if (rank != root) {
|
||||
return MCA_PML_CALL(send(sbuf, scount, sdtype, root,
|
||||
MCA_COLL_BASE_TAG_GATHER,
|
||||
MCA_PML_BASE_SEND_STANDARD, comm));
|
||||
}
|
||||
|
||||
/* I am the root, loop receiving the data. */
|
||||
|
||||
ompi_ddt_get_extent(rdtype, &lb, &extent);
|
||||
incr = extent * rcount;
|
||||
for (i = 0, ptmp = (char *) rbuf; i < size; ++i, ptmp += incr) {
|
||||
if (i == rank) {
|
||||
if (MPI_IN_PLACE != sbuf) {
|
||||
err = ompi_ddt_sndrcv(sbuf, scount, sdtype,
|
||||
ptmp, rcount, rdtype);
|
||||
} else {
|
||||
err = MPI_SUCCESS;
|
||||
}
|
||||
} else {
|
||||
err = MCA_PML_CALL(recv(ptmp, rcount, rdtype, i,
|
||||
MCA_COLL_BASE_TAG_GATHER,
|
||||
comm, MPI_STATUS_IGNORE));
|
||||
}
|
||||
if (MPI_SUCCESS != err) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
/* All done */
|
||||
|
||||
return MPI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/* copied function (with appropriate renaming) ends here */
|
||||
|
||||
/* 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_gather_intra_check_forced_init(coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices)
|
||||
{
|
||||
int rc, max_alg = 2, requested_alg;
|
||||
|
||||
ompi_coll_tuned_forced_max_algorithms[GATHER] = max_alg;
|
||||
|
||||
rc = mca_base_param_reg_int (&mca_coll_tuned_component.super.collm_version,
|
||||
"gather_algorithm_count",
|
||||
"Number of gather 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,
|
||||
"gather_algorithm",
|
||||
"Which gather algorithm is used. Can be locked down to choice of: 0 ignore, 1 basic linear, 2 binomial.",
|
||||
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, "Gather 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);
|
||||
}
|
||||
|
||||
mca_param_indices->segsize_param_index
|
||||
= mca_base_param_reg_int(&mca_coll_tuned_component.super.collm_version,
|
||||
"gather_algorithm_segmentsize",
|
||||
"Segment size in bytes used by default for gather algorithms. Only has meaning if algorithm is forced and supports segmenting. 0 bytes means no segmentation. Currently, available algorithms do not support segmentation.",
|
||||
false, false, 0, NULL);
|
||||
|
||||
mca_param_indices->tree_fanout_param_index
|
||||
= mca_base_param_reg_int(&mca_coll_tuned_component.super.collm_version,
|
||||
"gather_algorithm_tree_fanout",
|
||||
"Fanout for n-tree used for gather algorithms. Only has meaning if algorithm is forced and supports n-tree topo based operation. Currently, available algorithms do not support n-tree topologies.",
|
||||
false, false,
|
||||
ompi_coll_tuned_init_tree_fanout, /* get system wide default */
|
||||
NULL);
|
||||
|
||||
mca_param_indices->chain_fanout_param_index
|
||||
= mca_base_param_reg_int(&mca_coll_tuned_component.super.collm_version,
|
||||
"gather_algorithm_chain_fanout",
|
||||
"Fanout for chains used for gather algorithms. Only has meaning if algorithm is forced and supports chain topo based operation. Currently, available algorithms do not support chain topologies.",
|
||||
false, false,
|
||||
ompi_coll_tuned_init_chain_fanout, /* get system wide default */
|
||||
NULL);
|
||||
|
||||
return (MPI_SUCCESS);
|
||||
}
|
||||
|
||||
int
|
||||
ompi_coll_tuned_gather_intra_do_forced(void *sbuf, int scount,
|
||||
struct ompi_datatype_t *sdtype,
|
||||
void* rbuf, int rcount,
|
||||
struct ompi_datatype_t *rdtype,
|
||||
int root, struct ompi_communicator_t *comm)
|
||||
{
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"coll:tuned:gather_intra_do_forced selected algorithm %d",
|
||||
comm->c_coll_selected_data->user_forced[GATHER].algorithm));
|
||||
|
||||
switch (comm->c_coll_selected_data->user_forced[GATHER].algorithm) {
|
||||
case (0):
|
||||
return ompi_coll_tuned_gather_intra_dec_fixed (sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
case (1):
|
||||
return ompi_coll_tuned_gather_intra_basic_linear (sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
case (2):
|
||||
return ompi_coll_tuned_gather_intra_binomial(sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
default:
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"coll:tuned:gather_intra_do_forced attempt to select algorithm %d when only 0-%d is valid?",
|
||||
comm->c_coll_selected_data->user_forced[GATHER].algorithm,
|
||||
ompi_coll_tuned_forced_max_algorithms[GATHER]));
|
||||
return (MPI_ERR_ARG);
|
||||
} /* switch */
|
||||
}
|
||||
|
||||
int
|
||||
ompi_coll_tuned_gather_intra_do_this(void *sbuf, int scount,
|
||||
struct ompi_datatype_t *sdtype,
|
||||
void* rbuf, int rcount,
|
||||
struct ompi_datatype_t *rdtype,
|
||||
int root, struct ompi_communicator_t *comm,
|
||||
int algorithm, int faninout, int segsize)
|
||||
{
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"coll:tuned:gather_intra_do_this selected algorithm %d topo faninout %d segsize %d",
|
||||
algorithm, faninout, segsize));
|
||||
|
||||
switch (algorithm) {
|
||||
case (0):
|
||||
return ompi_coll_tuned_gather_intra_dec_fixed (sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
case (1):
|
||||
return ompi_coll_tuned_gather_intra_basic_linear (sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
case (2):
|
||||
return ompi_coll_tuned_gather_intra_binomial(sbuf, scount, sdtype,
|
||||
rbuf, rcount, rdtype,
|
||||
root, comm);
|
||||
default:
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"coll:tuned:allgather_intra_do_this attempt to select algorithm %d when only 0-%d is valid?",
|
||||
algorithm,
|
||||
ompi_coll_tuned_forced_max_algorithms[ALLGATHER]));
|
||||
return (MPI_ERR_ARG);
|
||||
} /* switch */
|
||||
}
|
||||
@ -113,8 +113,8 @@ static const mca_coll_base_module_1_0_0_t intra_dynamic = {
|
||||
/* NULL, */
|
||||
/* ompi_coll_tuned_exscan_intra_dec_dynamic, */
|
||||
NULL,
|
||||
/* ompi_coll_tuned_gather_intra_dec_dynamic, */
|
||||
NULL,
|
||||
ompi_coll_tuned_gather_intra_dec_dynamic,
|
||||
/* NULL, */
|
||||
/* ompi_coll_tuned_gatherv_intra_dec_dynamic, */
|
||||
NULL,
|
||||
ompi_coll_tuned_reduce_intra_dec_dynamic,
|
||||
@ -400,6 +400,7 @@ ompi_coll_tuned_module_init(struct ompi_communicator_t *comm)
|
||||
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]));
|
||||
ompi_coll_tuned_forced_getvalues (ompi_coll_tuned_forced_params[GATHER], &(data->user_forced[GATHER]));
|
||||
}
|
||||
|
||||
|
||||
@ -468,6 +469,9 @@ ompi_coll_tuned_module_init(struct ompi_communicator_t *comm)
|
||||
data->cached_bmtree = ompi_coll_tuned_topo_build_bmtree (comm, 0);
|
||||
data->cached_bmtree_root = 0;
|
||||
|
||||
/* binomial tree */
|
||||
data->cached_in_order_bmtree = ompi_coll_tuned_topo_build_in_order_bmtree (comm, 0);
|
||||
data->cached_in_order_bmtree_root = 0;
|
||||
/*
|
||||
* chains (fanout followed by pipelines)
|
||||
* are more difficuilt as the fan out really really depends on message size [sometimes]..
|
||||
@ -523,6 +527,9 @@ int ompi_coll_tuned_module_finalize(struct ompi_communicator_t *comm)
|
||||
if (comm->c_coll_selected_data->cached_bmtree) { /* destroy bmtree if defined */
|
||||
ompi_coll_tuned_topo_destroy_tree (&comm->c_coll_selected_data->cached_bmtree);
|
||||
}
|
||||
if (comm->c_coll_selected_data->cached_in_order_bmtree) { /* destroy bmtree if defined */
|
||||
ompi_coll_tuned_topo_destroy_tree (&comm->c_coll_selected_data->cached_in_order_bmtree);
|
||||
}
|
||||
if (comm->c_coll_selected_data->cached_chain) { /* destroy general chain if defined */
|
||||
ompi_coll_tuned_topo_destroy_tree (&comm->c_coll_selected_data->cached_chain);
|
||||
}
|
||||
|
||||
@ -307,6 +307,18 @@ int ompi_coll_tuned_topo_destroy_tree( ompi_coll_tree_t** tree )
|
||||
return OMPI_SUCCESS;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Here are some of the examples of this tree:
|
||||
* size == 2 size = 4 size = 8
|
||||
* 0 0 0
|
||||
* / | \ / | \
|
||||
* 1 2 1 4 2 1
|
||||
* | | |\
|
||||
* 3 6 5 3
|
||||
* |
|
||||
* 7
|
||||
*/
|
||||
ompi_coll_tree_t*
|
||||
ompi_coll_tuned_topo_build_bmtree( struct ompi_communicator_t* comm,
|
||||
int root )
|
||||
@ -375,6 +387,82 @@ ompi_coll_tuned_topo_build_bmtree( struct ompi_communicator_t* comm,
|
||||
return bmtree;
|
||||
}
|
||||
|
||||
/*
|
||||
* Constructs in-order binomial tree which can be used for gather/scatter
|
||||
* operations.
|
||||
*
|
||||
* Here are some of the examples of this tree:
|
||||
* size == 2 size = 4 size = 8
|
||||
* 0 0 0
|
||||
* / / | / | \
|
||||
* 1 1 2 1 2 4
|
||||
* | | | \
|
||||
* 3 3 5 6
|
||||
* |
|
||||
* 7
|
||||
*/
|
||||
ompi_coll_tree_t*
|
||||
ompi_coll_tuned_topo_build_in_order_bmtree( struct ompi_communicator_t* comm,
|
||||
int root )
|
||||
{
|
||||
int childs = 0;
|
||||
int rank, vrank;
|
||||
int size;
|
||||
int mask = 1;
|
||||
int remote;
|
||||
ompi_coll_tree_t *bmtree;
|
||||
int i;
|
||||
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,"coll:tuned:topo:build_in_order_bmtree rt %d", root));
|
||||
|
||||
/*
|
||||
* Get size and rank of the process in this communicator
|
||||
*/
|
||||
size = ompi_comm_size(comm);
|
||||
rank = ompi_comm_rank(comm);
|
||||
|
||||
vrank = (rank - root + size) % size;
|
||||
|
||||
bmtree = (ompi_coll_tree_t*)malloc(sizeof(ompi_coll_tree_t));
|
||||
if (!bmtree) {
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,"coll:tuned:topo:build_bmtree PANIC out of memory"));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bmtree->tree_bmtree = 1;
|
||||
bmtree->tree_root = MPI_UNDEFINED;
|
||||
bmtree->tree_nextsize = MPI_UNDEFINED;
|
||||
for(i=0;i<MAXTREEFANOUT;i++) {
|
||||
bmtree->tree_next[i] = -1;
|
||||
}
|
||||
|
||||
if (root == rank) {
|
||||
bmtree->tree_prev = root;
|
||||
}
|
||||
|
||||
while (mask < size) {
|
||||
remote = vrank ^ mask;
|
||||
if (remote < vrank) {
|
||||
bmtree->tree_prev = (remote + root) % size;
|
||||
break;
|
||||
} else if (remote < size) {
|
||||
bmtree->tree_next[childs] = (remote + root) % size;
|
||||
childs++;
|
||||
if (childs==MAXTREEFANOUT) {
|
||||
OPAL_OUTPUT((ompi_coll_tuned_stream,
|
||||
"coll:tuned:topo:build_bmtree max fanout incorrect %d needed %d",
|
||||
MAXTREEFANOUT, childs));
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
mask <<= 1;
|
||||
}
|
||||
bmtree->tree_nextsize = childs;
|
||||
bmtree->tree_root = root;
|
||||
|
||||
return bmtree;
|
||||
}
|
||||
|
||||
|
||||
ompi_coll_tree_t*
|
||||
ompi_coll_tuned_topo_build_chain( int fanout,
|
||||
|
||||
@ -46,7 +46,9 @@ extern "C" {
|
||||
ompi_coll_tree_t*
|
||||
ompi_coll_tuned_topo_build_bmtree( struct ompi_communicator_t* comm,
|
||||
int root );
|
||||
|
||||
ompi_coll_tree_t*
|
||||
ompi_coll_tuned_topo_build_in_order_bmtree( struct ompi_communicator_t* comm,
|
||||
int root );
|
||||
ompi_coll_tree_t*
|
||||
ompi_coll_tuned_topo_build_chain( int fanout,
|
||||
struct ompi_communicator_t* com,
|
||||
|
||||
Загрузка…
x
Ссылка в новой задаче
Block a user