/* selector for collective algorithms based on mvapich decision logic */
-/* Copyright (c) 2009-2019. The SimGrid Team.
+/* Copyright (c) 2009-2021. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
#include "smpi_mvapich2_selector_stampede.hpp"
-namespace simgrid{
-namespace smpi{
+namespace simgrid {
+namespace smpi {
-int Coll_alltoall_mvapich2::alltoall( void *sendbuf, int sendcount,
- MPI_Datatype sendtype,
- void* recvbuf, int recvcount,
- MPI_Datatype recvtype,
- MPI_Comm comm)
+int alltoall__mvapich2( const void *sendbuf, int sendcount,
+ MPI_Datatype sendtype,
+ void* recvbuf, int recvcount,
+ MPI_Datatype recvtype,
+ MPI_Comm comm)
{
- if(mv2_alltoall_table_ppn_conf==NULL)
+ if (mv2_alltoall_table_ppn_conf == nullptr)
init_mv2_alltoall_tables_stampede();
int sendtype_size, recvtype_size, comm_size;
- char * tmp_buf = NULL;
int mpi_errno=MPI_SUCCESS;
int range = 0;
int range_threshold = 0;
mv2_alltoall_thresholds_table[conf_index][range].in_place_algo_table[range_threshold].min
||nbytes > mv2_alltoall_thresholds_table[conf_index][range].in_place_algo_table[range_threshold].max
) {
- tmp_buf = (char *)smpi_get_tmp_sendbuffer( comm_size * recvcount * recvtype_size );
- Datatype::copy((char *)recvbuf,
- comm_size*recvcount, recvtype,
- (char *)tmp_buf,
- comm_size*recvcount, recvtype);
+ unsigned char* tmp_buf = smpi_get_tmp_sendbuffer(comm_size * recvcount * recvtype_size);
+ Datatype::copy(recvbuf, comm_size * recvcount, recvtype, tmp_buf, comm_size * recvcount, recvtype);
- mpi_errno = MV2_Alltoall_function(tmp_buf, recvcount, recvtype,
- recvbuf, recvcount, recvtype,
- comm );
- smpi_free_tmp_buffer(tmp_buf);
+ mpi_errno = MV2_Alltoall_function(tmp_buf, recvcount, recvtype, recvbuf, recvcount, recvtype, comm);
+ smpi_free_tmp_buffer(tmp_buf);
} else {
mpi_errno = MPIR_Alltoall_inplace_MV2(sendbuf, sendcount, sendtype,
recvbuf, recvcount, recvtype,
return (mpi_errno);
}
-int Coll_allgather_mvapich2::allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+int allgather__mvapich2(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
void *recvbuf, int recvcount, MPI_Datatype recvtype,
MPI_Comm comm)
{
int mpi_errno = MPI_SUCCESS;
long nbytes = 0, comm_size, recvtype_size;
int range = 0;
- int partial_sub_ok = 0;
+ bool partial_sub_ok = false;
int conf_index = 0;
int range_threshold = 0;
- int is_two_level = 0;
MPI_Comm shmem_comm;
//MPI_Comm *shmem_commptr=NULL;
/* Get the size of the communicator */
recvtype_size=recvtype->size();
nbytes = recvtype_size * recvcount;
- if(mv2_allgather_table_ppn_conf==NULL)
+ if (mv2_allgather_table_ppn_conf == nullptr)
init_mv2_allgather_tables_stampede();
if(comm->get_leaders_comm()==MPI_COMM_NULL){
do {
if (local_size == mv2_allgather_table_ppn_conf[i]) {
conf_index = i;
- partial_sub_ok = 1;
+ partial_sub_ok = true;
break;
}
i++;
} while(i < mv2_allgather_num_ppn_conf);
}
conf_check_end:
- if (partial_sub_ok != 1) {
+ if (not partial_sub_ok) {
conf_index = 0;
}
mv2_allgather_thresholds_table[conf_index][range].inter_leader[range_threshold].
MV2_pt_Allgatherction;
- is_two_level = mv2_allgather_thresholds_table[conf_index][range].two_level[range_threshold];
+ bool is_two_level = mv2_allgather_thresholds_table[conf_index][range].two_level[range_threshold];
/* intracommunicator */
- if(is_two_level ==1){
- if(partial_sub_ok ==1){
+ if (is_two_level) {
+ if (partial_sub_ok) {
if (comm->is_blocked()){
mpi_errno = MPIR_2lvl_Allgather_MV2(sendbuf, sendcount, sendtype,
recvbuf, recvcount, recvtype,
comm);
}else{
- mpi_errno = Coll_allgather_mpich::allgather(sendbuf, sendcount, sendtype,
+ mpi_errno = allgather__mpich(sendbuf, sendcount, sendtype,
recvbuf, recvcount, recvtype,
comm);
}
return mpi_errno;
}
-int Coll_gather_mvapich2::gather(void *sendbuf,
+int gather__mvapich2(const void *sendbuf,
int sendcnt,
MPI_Datatype sendtype,
void *recvbuf,
MPI_Datatype recvtype,
int root, MPI_Comm comm)
{
- if(mv2_gather_thresholds_table==NULL)
+ if (mv2_gather_thresholds_table == nullptr)
init_mv2_gather_tables_stampede();
int mpi_errno = MPI_SUCCESS;
} else {
// Indeed, direct (non SMP-aware)gather is MPICH one
- mpi_errno = Coll_gather_mpich::gather(sendbuf, sendcnt, sendtype,
+ mpi_errno = gather__mpich(sendbuf, sendcnt, sendtype,
recvbuf, recvcnt, recvtype,
root, comm);
}
return mpi_errno;
}
-int Coll_allgatherv_mvapich2::allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
- void *recvbuf, int *recvcounts, int *displs,
+int allgatherv__mvapich2(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
+ void *recvbuf, const int *recvcounts, const int *displs,
MPI_Datatype recvtype, MPI_Comm comm )
{
int mpi_errno = MPI_SUCCESS;
int range_threshold = 0;
long nbytes = 0;
- if(mv2_allgatherv_thresholds_table==NULL)
+ if (mv2_allgatherv_thresholds_table == nullptr)
init_mv2_allgatherv_tables_stampede();
comm_size = comm->size();
-int Coll_allreduce_mvapich2::allreduce(void *sendbuf,
+int allreduce__mvapich2(const void *sendbuf,
void *recvbuf,
int count,
MPI_Datatype datatype,
return MPI_SUCCESS;
}
- if (mv2_allreduce_thresholds_table == NULL)
+ if (mv2_allreduce_thresholds_table == nullptr)
init_mv2_allreduce_tables_stampede();
/* check if multiple threads are calling this collective function */
MPI_Aint sendtype_size = 0;
long nbytes = 0;
- int is_commutative = 0;
MPI_Aint true_lb, true_extent;
sendtype_size=datatype->size();
nbytes = count * sendtype_size;
datatype->extent(&true_lb, &true_extent);
- is_commutative = op->is_commutative();
+ bool is_commutative = op->is_commutative();
{
int range = 0, range_threshold = 0, range_threshold_intra = 0;
- int is_two_level = 0;
+ bool is_two_level = false;
/* Search for the corresponding system size inside the tuning table */
while ((range < (mv2_size_allreduce_tuning_table - 1)) &&
range++;
}
/* Search for corresponding inter-leader function */
- /* skip mcast poiters if mcast is not available */
- if(mv2_allreduce_thresholds_table[range].mcast_enabled != 1){
+ /* skip mcast pointers if mcast is not available */
+ if (not mv2_allreduce_thresholds_table[range].mcast_enabled) {
while ((range_threshold < (mv2_allreduce_thresholds_table[range].size_inter_table - 1))
&& ((mv2_allreduce_thresholds_table[range].
inter_leader[range_threshold].MV2_pt_Allreducection
&& (mv2_allreduce_thresholds_table[range].inter_leader[range_threshold].max != -1)) {
range_threshold++;
}
- if(mv2_allreduce_thresholds_table[range].is_two_level_allreduce[range_threshold] == 1){
- is_two_level = 1;
+ if (mv2_allreduce_thresholds_table[range].is_two_level_allreduce[range_threshold]) {
+ is_two_level = true;
}
/* Search for corresponding intra-node function */
while ((range_threshold_intra <
{
MV2_Allreducection = &MPIR_Allreduce_pt2pt_rd_MV2;
}
- if(is_two_level != 1) {
+ if (not is_two_level) {
MV2_Allreducection = &MPIR_Allreduce_pt2pt_rd_MV2;
}
}
- if(is_two_level == 1){
- // check if shm is ready, if not use other algorithm first
- if (is_commutative) {
+ if (is_two_level) {
+ // check if shm is ready, if not use other algorithm first
+ if (is_commutative) {
if(comm->get_leaders_comm()==MPI_COMM_NULL){
comm->init_smp();
}
mpi_errno = MPIR_Allreduce_two_level_MV2(sendbuf, recvbuf, count,
datatype, op, comm);
- } else {
+ } else {
mpi_errno = MPIR_Allreduce_pt2pt_rd_MV2(sendbuf, recvbuf, count,
datatype, op, comm);
- }
+ }
} else {
mpi_errno = MV2_Allreducection(sendbuf, recvbuf, count,
datatype, op, comm);
}
-int Coll_alltoallv_mvapich2::alltoallv(void *sbuf, int *scounts, int *sdisps,
+int alltoallv__mvapich2(const void *sbuf, const int *scounts, const int *sdisps,
MPI_Datatype sdtype,
- void *rbuf, int *rcounts, int *rdisps,
+ void *rbuf, const int *rcounts, const int *rdisps,
MPI_Datatype rdtype,
MPI_Comm comm
)
{
if (sbuf == MPI_IN_PLACE) {
- return Coll_alltoallv_ompi_basic_linear::alltoallv(sbuf, scounts, sdisps, sdtype,
- rbuf, rcounts, rdisps,rdtype,
- comm);
+ return alltoallv__ompi_basic_linear(sbuf, scounts, sdisps, sdtype,
+ rbuf, rcounts, rdisps, rdtype,
+ comm);
} else /* For starters, just keep the original algorithm. */
- return Coll_alltoallv_ring::alltoallv(sbuf, scounts, sdisps, sdtype,
- rbuf, rcounts, rdisps,rdtype,
- comm);
+ return alltoallv__ring(sbuf, scounts, sdisps, sdtype,
+ rbuf, rcounts, rdisps, rdtype,
+ comm);
}
-int Coll_barrier_mvapich2::barrier(MPI_Comm comm)
+int barrier__mvapich2(MPI_Comm comm)
{
- return Coll_barrier_mvapich2_pair::barrier(comm);
+ return barrier__mvapich2_pair(comm);
}
-int Coll_bcast_mvapich2::bcast(void *buffer,
- int count,
- MPI_Datatype datatype,
- int root, MPI_Comm comm)
+int bcast__mvapich2(void *buffer,
+ int count,
+ MPI_Datatype datatype,
+ int root, MPI_Comm comm)
{
int mpi_errno = MPI_SUCCESS;
int comm_size/*, rank*/;
- int two_level_bcast = 1;
+ bool two_level_bcast = true;
long nbytes = 0;
int range = 0;
int range_threshold = 0;
int range_threshold_intra = 0;
- // int is_homogeneous, is_contig;
MPI_Aint type_size;
//, position;
- // void *tmp_buf = NULL;
+ // unsigned char *tmp_buf = NULL;
MPI_Comm shmem_comm;
//MPID_Datatype *dtp;
comm_size = comm->size();
//rank = comm->rank();
- //is_contig=1;
+ // bool is_contig = true;
/* if (HANDLE_GET_KIND(datatype) == HANDLE_KIND_BUILTIN)*/
-/* is_contig = 1;*/
+/* is_contig = true;*/
/* else {*/
/* MPID_Datatype_get_ptr(datatype, dtp);*/
/* is_contig = dtp->is_contig;*/
/* }*/
- // is_homogeneous = 1;
+ // bool is_homogeneous = true;
/* MPI_Type_size() might not give the accurate size of the packed
* datatype for heterogeneous systems (because of padding, encoding,
zcpy_knomial_factor = mv2_pipelined_zcpy_knomial_factor;
}
- if(MV2_Bcast_intra_node_function == NULL) {
- /* if tuning table do not have any intra selection, set func pointer to
- ** default one for mcast intra node */
- MV2_Bcast_intra_node_function = &MPIR_Shmem_Bcast_MV2;
+ if (MV2_Bcast_intra_node_function == nullptr) {
+ /* if tuning table do not have any intra selection, set func pointer to
+ ** default one for mcast intra node */
+ MV2_Bcast_intra_node_function = &MPIR_Shmem_Bcast_MV2;
}
/* Set value of pipeline segment size */
#else
mv2_bcast_thresholds_table[range].is_two_level_bcast[range_threshold];
#endif
- if (two_level_bcast == 1) {
+ if (two_level_bcast) {
// if (not is_contig || not is_homogeneous) {
- // tmp_buf = (void*)smpi_get_tmp_sendbuffer(nbytes);
-
- /* position = 0;*/
- /* if (rank == root) {*/
- /* mpi_errno =*/
- /* MPIR_Pack_impl(buffer, count, datatype, tmp_buf, nbytes, &position);*/
- /* if (mpi_errno)*/
- /* MPIU_ERR_POP(mpi_errno);*/
- /* }*/
- // }
+// tmp_buf = smpi_get_tmp_sendbuffer(nbytes);
+
+/* position = 0;*/
+/* if (rank == root) {*/
+/* mpi_errno =*/
+/* MPIR_Pack_impl(buffer, count, datatype, tmp_buf, nbytes, &position);*/
+/* if (mpi_errno)*/
+/* MPIU_ERR_POP(mpi_errno);*/
+/* }*/
+// }
#ifdef CHANNEL_MRAIL_GEN2
if ((mv2_enable_zcpy_bcast == 1) &&
(&MPIR_Pipelined_Bcast_Zcpy_MV2 == MV2_Bcast_function)) {
-int Coll_reduce_mvapich2::reduce( void *sendbuf,
+int reduce__mvapich2(const void *sendbuf,
void *recvbuf,
int count,
MPI_Datatype datatype,
MPI_Op op, int root, MPI_Comm comm)
{
- if(mv2_reduce_thresholds_table == NULL)
+ if (mv2_reduce_thresholds_table == nullptr)
init_mv2_reduce_tables_stampede();
int mpi_errno = MPI_SUCCESS;
int range = 0;
int range_threshold = 0;
int range_intra_threshold = 0;
- int is_commutative, pof2;
+ int pof2;
int comm_size = 0;
long nbytes = 0;
int sendtype_size;
- int is_two_level = 0;
+ bool is_two_level = false;
comm_size = comm->size();
sendtype_size=datatype->size();
if (count == 0)
return MPI_SUCCESS;
- is_commutative = (op==MPI_OP_NULL || op->is_commutative());
+ bool is_commutative = (op == MPI_OP_NULL || op->is_commutative());
/* find nearest power-of-two less than or equal to comm_size */
for( pof2 = 1; pof2 <= comm_size; pof2 <<= 1 );
{
mv2_reduce_inter_knomial_factor = mv2_reduce_thresholds_table[range].inter_k_degree;
}
- if(mv2_reduce_thresholds_table[range].is_two_level_reduce[range_threshold] == 1){
- is_two_level = 1;
+ if (mv2_reduce_thresholds_table[range].is_two_level_reduce[range_threshold]) {
+ is_two_level = true;
}
/* We call Reduce function */
- if(is_two_level == 1)
- {
- if (is_commutative == 1) {
+ if (is_two_level) {
+ if (is_commutative) {
if(comm->get_leaders_comm()==MPI_COMM_NULL){
comm->init_smp();
}
mpi_errno = MPIR_Reduce_two_level_helper_MV2(sendbuf, recvbuf, count,
datatype, op, root, comm);
- } else {
+ } else {
mpi_errno = MPIR_Reduce_binomial_MV2(sendbuf, recvbuf, count,
datatype, op, root, comm);
- }
+ }
} else if(MV2_Reduce_function == &MPIR_Reduce_inter_knomial_wrapper_MV2 ){
- if(is_commutative ==1)
+ if (is_commutative)
{
mpi_errno = MV2_Reduce_function(sendbuf, recvbuf, count,
datatype, op, root, comm);
}
-int Coll_reduce_scatter_mvapich2::reduce_scatter(void *sendbuf, void *recvbuf, int *recvcnts,
+int reduce_scatter__mvapich2(const void *sendbuf, void *recvbuf, const int *recvcnts,
MPI_Datatype datatype, MPI_Op op,
MPI_Comm comm)
{
int mpi_errno = MPI_SUCCESS;
int i = 0, comm_size = comm->size(), total_count = 0, type_size =
0, nbytes = 0;
- int is_commutative = 0;
int* disps = new int[comm_size];
- if(mv2_red_scat_thresholds_table==NULL)
+ if (mv2_red_scat_thresholds_table == nullptr)
init_mv2_reduce_scatter_tables_stampede();
- is_commutative=(op==MPI_OP_NULL || op->is_commutative());
+ bool is_commutative = (op == MPI_OP_NULL || op->is_commutative());
for (i = 0; i < comm_size; i++) {
disps[i] = total_count;
total_count += recvcnts[i];
recvcnts, datatype,
op, comm);
} else {
- int is_block_regular = 1;
+ bool is_block_regular = true;
for (i = 0; i < (comm_size - 1); ++i) {
if (recvcnts[i] != recvcnts[i+1]) {
- is_block_regular = 0;
+ is_block_regular = false;
break;
}
}
recvcnts, datatype,
op, comm);
}
- mpi_errno = Coll_reduce_scatter_mpich_rdb::reduce_scatter(sendbuf, recvbuf,
- recvcnts, datatype,
- op, comm);
+ mpi_errno = reduce_scatter__mpich_rdb(sendbuf, recvbuf,
+ recvcnts, datatype,
+ op, comm);
}
delete[] disps;
return mpi_errno;
-int Coll_scatter_mvapich2::scatter(void *sendbuf,
+int scatter__mvapich2(const void *sendbuf,
int sendcnt,
MPI_Datatype sendtype,
void *recvbuf,
int mpi_errno = MPI_SUCCESS;
// int mpi_errno_ret = MPI_SUCCESS;
int rank, nbytes, comm_size;
- int partial_sub_ok = 0;
+ bool partial_sub_ok = false;
int conf_index = 0;
MPI_Comm shmem_comm;
// MPID_Comm *shmem_commptr=NULL;
- if(mv2_scatter_thresholds_table==NULL)
- init_mv2_scatter_tables_stampede();
+ if (mv2_scatter_thresholds_table == nullptr)
+ init_mv2_scatter_tables_stampede();
- if(comm->get_leaders_comm()==MPI_COMM_NULL){
- comm->init_smp();
- }
+ if (comm->get_leaders_comm() == MPI_COMM_NULL) {
+ comm->init_smp();
+ }
comm_size = comm->size();
do {
if (local_size == mv2_scatter_table_ppn_conf[i]) {
conf_index = i;
- partial_sub_ok = 1;
+ partial_sub_ok = true;
break;
}
i++;
}
}
- if (partial_sub_ok != 1) {
+ if (not partial_sub_ok) {
conf_index = 0;
}
} else
#endif /*#if defined(_MCST_SUPPORT_) */
{
- if(mv2_scatter_thresholds_table[conf_index][range].inter_leader[range_threshold + 1].
- MV2_pt_Scatter_function != NULL) {
- MV2_Scatter_function = mv2_scatter_thresholds_table[conf_index][range].inter_leader[range_threshold + 1]
- .MV2_pt_Scatter_function;
- } else {
- /* Fallback! */
- MV2_Scatter_function = &MPIR_Scatter_MV2_Binomial;
- }
+ if (mv2_scatter_thresholds_table[conf_index][range].inter_leader[range_threshold + 1].MV2_pt_Scatter_function !=
+ nullptr) {
+ MV2_Scatter_function =
+ mv2_scatter_thresholds_table[conf_index][range].inter_leader[range_threshold + 1].MV2_pt_Scatter_function;
+ } else {
+ /* Fallback! */
+ MV2_Scatter_function = &MPIR_Scatter_MV2_Binomial;
+ }
}
}
