X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d53d00d608a60a6f05e77ea7b7cd5c4e544d7ab1..84402e8e2ee2a2d0bef25fdceb0a263ed8b471f6:/src/smpi/colls/smpi_mvapich2_selector.cpp diff --git a/src/smpi/colls/smpi_mvapich2_selector.cpp b/src/smpi/colls/smpi_mvapich2_selector.cpp index 54d259dd4b..ac8185c258 100644 --- a/src/smpi/colls/smpi_mvapich2_selector.cpp +++ b/src/smpi/colls/smpi_mvapich2_selector.cpp @@ -1,37 +1,38 @@ /* selector for collective algorithms based on mvapich decision logic */ -/* Copyright (c) 2009-2010, 2013-2014. The SimGrid Team. +/* Copyright (c) 2009-2020. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ -#include "colls_private.h" +#include "colls_private.hpp" -#include "smpi_mvapich2_selector_stampede.h" +#include "smpi_mvapich2_selector_stampede.hpp" +namespace simgrid { +namespace smpi { -int smpi_coll_tuned_alltoall_mvapich2( 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) 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; int conf_index = 0; - comm_size = smpi_comm_size(comm); + comm_size = comm->size(); - sendtype_size=smpi_datatype_size(sendtype); - recvtype_size=smpi_datatype_size(recvtype); + sendtype_size=sendtype->size(); + recvtype_size=recvtype->size(); long nbytes = sendtype_size * sendcount; /* check if safe to use partial subscription mode */ @@ -61,16 +62,11 @@ int smpi_coll_tuned_alltoall_mvapich2( void *sendbuf, int sendcount, 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 ); - mpi_errno = smpi_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, @@ -82,7 +78,7 @@ int smpi_coll_tuned_alltoall_mvapich2( void *sendbuf, int sendcount, return (mpi_errno); } -int smpi_coll_tuned_allgather_mvapich2(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) { @@ -90,30 +86,27 @@ int smpi_coll_tuned_allgather_mvapich2(void *sendbuf, int sendcount, MPI_Datatyp 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; - int local_size = -1; MPI_Comm shmem_comm; //MPI_Comm *shmem_commptr=NULL; /* Get the size of the communicator */ - comm_size = smpi_comm_size(comm); - recvtype_size=smpi_datatype_size(recvtype); + comm_size = comm->size(); + recvtype_size=recvtype->size(); nbytes = recvtype_size * recvcount; if(mv2_allgather_table_ppn_conf==NULL) init_mv2_allgather_tables_stampede(); - - if(smpi_comm_get_leaders_comm(comm)==MPI_COMM_NULL){ - smpi_comm_init_smp(comm); + + if(comm->get_leaders_comm()==MPI_COMM_NULL){ + comm->init_smp(); } - int i; - if (smpi_comm_is_uniform(comm)){ - shmem_comm = smpi_comm_get_intra_comm(comm); - local_size = smpi_comm_size(shmem_comm); - i = 0; + if (comm->is_uniform()){ + shmem_comm = comm->get_intra_comm(); + int local_size = shmem_comm->size(); + int i = 0; if (mv2_allgather_table_ppn_conf[0] == -1) { // Indicating user defined tuning conf_index = 0; @@ -122,17 +115,17 @@ int smpi_coll_tuned_allgather_mvapich2(void *sendbuf, int sendcount, MPI_Datatyp 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; } - + /* Search for the corresponding system size inside the tuning table */ while ((range < (mv2_size_allgather_tuning_table[conf_index] - 1)) && (comm_size > @@ -149,21 +142,21 @@ int smpi_coll_tuned_allgather_mvapich2(void *sendbuf, int sendcount, MPI_Datatyp } /* Set inter-leader pt */ - MV2_Allgather_function = + MV2_Allgatherction = mv2_allgather_thresholds_table[conf_index][range].inter_leader[range_threshold]. - MV2_pt_Allgather_function; + 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 (smpi_comm_is_blocked(comm)){ + 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 = smpi_coll_tuned_allgather_mpich(sendbuf, sendcount, sendtype, + mpi_errno = allgather__mpich(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm); } @@ -172,10 +165,10 @@ int smpi_coll_tuned_allgather_mvapich2(void *sendbuf, int sendcount, MPI_Datatyp recvbuf, recvcount, recvtype, comm); } - } else if(MV2_Allgather_function == &MPIR_Allgather_Bruck_MV2 - || MV2_Allgather_function == &MPIR_Allgather_RD_MV2 - || MV2_Allgather_function == &MPIR_Allgather_Ring_MV2) { - mpi_errno = MV2_Allgather_function(sendbuf, sendcount, sendtype, + } else if(MV2_Allgatherction == &MPIR_Allgather_Bruck_MV2 + || MV2_Allgatherction == &MPIR_Allgather_RD_MV2 + || MV2_Allgatherction == &MPIR_Allgather_Ring_MV2) { + mpi_errno = MV2_Allgatherction(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm); }else{ @@ -185,8 +178,7 @@ int smpi_coll_tuned_allgather_mvapich2(void *sendbuf, int sendcount, MPI_Datatyp return mpi_errno; } - -int smpi_coll_tuned_gather_mvapich2(void *sendbuf, +int gather__mvapich2(const void *sendbuf, int sendcnt, MPI_Datatype sendtype, void *recvbuf, @@ -202,18 +194,15 @@ int smpi_coll_tuned_gather_mvapich2(void *sendbuf, int range_threshold = 0; int range_intra_threshold = 0; long nbytes = 0; - int comm_size = 0; - int recvtype_size, sendtype_size; - int rank = -1; - comm_size = smpi_comm_size(comm); - rank = smpi_comm_rank(comm); + int comm_size = comm->size(); + int rank = comm->rank(); if (rank == root) { - recvtype_size=smpi_datatype_size(recvtype); - nbytes = recvcnt * recvtype_size; + int recvtype_size = recvtype->size(); + nbytes = recvcnt * recvtype_size; } else { - sendtype_size=smpi_datatype_size(sendtype); - nbytes = sendcnt * sendtype_size; + int sendtype_size = sendtype->size(); + nbytes = sendcnt * sendtype_size; } /* Search for the corresponding system size inside the tuning table */ @@ -238,24 +227,24 @@ int smpi_coll_tuned_gather_mvapich2(void *sendbuf, -1)) { range_intra_threshold++; } - - if (smpi_comm_is_blocked(comm) ) { - // Set intra-node function pt for gather_two_level - MV2_Gather_intra_node_function = + + if (comm->is_blocked() ) { + // Set intra-node function pt for gather_two_level + MV2_Gather_intra_node_function = mv2_gather_thresholds_table[range].intra_node[range_intra_threshold]. MV2_pt_Gather_function; - //Set inter-leader pt + //Set inter-leader pt MV2_Gather_inter_leader_function = mv2_gather_thresholds_table[range].inter_leader[range_threshold]. MV2_pt_Gather_function; - // We call Gather function + // We call Gather function mpi_errno = MV2_Gather_inter_leader_function(sendbuf, sendcnt, sendtype, recvbuf, recvcnt, recvtype, root, comm); } else { // Indeed, direct (non SMP-aware)gather is MPICH one - mpi_errno = smpi_coll_tuned_gather_mpich(sendbuf, sendcnt, sendtype, + mpi_errno = gather__mpich(sendbuf, sendcnt, sendtype, recvbuf, recvcnt, recvtype, root, comm); } @@ -263,9 +252,8 @@ int smpi_coll_tuned_gather_mvapich2(void *sendbuf, return mpi_errno; } - -int smpi_coll_tuned_allgatherv_mvapich2(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; @@ -276,12 +264,12 @@ int smpi_coll_tuned_allgatherv_mvapich2(void *sendbuf, int sendcount, MPI_Dataty if(mv2_allgatherv_thresholds_table==NULL) init_mv2_allgatherv_tables_stampede(); - comm_size = smpi_comm_size(comm); + comm_size = comm->size(); total_count = 0; for (i = 0; i < comm_size; i++) total_count += recvcounts[i]; - recvtype_size=smpi_datatype_size(recvtype); + recvtype_size=recvtype->size(); nbytes = total_count * recvtype_size; /* Search for the corresponding system size inside the tuning table */ @@ -304,13 +292,9 @@ int smpi_coll_tuned_allgatherv_mvapich2(void *sendbuf, int sendcount, MPI_Dataty if (MV2_Allgatherv_function == &MPIR_Allgatherv_Rec_Doubling_MV2) { - if(!(comm_size & (comm_size - 1))) - { - mpi_errno = - MPIR_Allgatherv_Rec_Doubling_MV2(sendbuf, sendcount, - sendtype, recvbuf, - recvcounts, displs, - recvtype, comm); + if (not(comm_size & (comm_size - 1))) { + mpi_errno = + MPIR_Allgatherv_Rec_Doubling_MV2(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm); } else { mpi_errno = MPIR_Allgatherv_Bruck_MV2(sendbuf, sendcount, @@ -330,7 +314,7 @@ int smpi_coll_tuned_allgatherv_mvapich2(void *sendbuf, int sendcount, MPI_Dataty -int smpi_coll_tuned_allreduce_mvapich2(void *sendbuf, +int allreduce__mvapich2(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, @@ -341,8 +325,8 @@ int smpi_coll_tuned_allreduce_mvapich2(void *sendbuf, //int rank = 0, int comm_size = 0; - comm_size = smpi_comm_size(comm); - //rank = smpi_comm_rank(comm); + comm_size = comm->size(); + //rank = comm->rank(); if (count == 0) { return MPI_SUCCESS; @@ -355,33 +339,32 @@ int smpi_coll_tuned_allreduce_mvapich2(void *sendbuf, MPI_Aint sendtype_size = 0; long nbytes = 0; - int range = 0, range_threshold = 0, range_threshold_intra = 0; - int is_two_level = 0; - int is_commutative = 0; MPI_Aint true_lb, true_extent; - sendtype_size=smpi_datatype_size(datatype); + sendtype_size=datatype->size(); nbytes = count * sendtype_size; - smpi_datatype_extent(datatype, &true_lb, &true_extent); - //MPI_Op *op_ptr; - //is_commutative = smpi_op_is_commute(op); + datatype->extent(&true_lb, &true_extent); + bool is_commutative = op->is_commutative(); { + int range = 0, range_threshold = 0, range_threshold_intra = 0; + bool is_two_level = false; + /* Search for the corresponding system size inside the tuning table */ while ((range < (mv2_size_allreduce_tuning_table - 1)) && (comm_size > mv2_allreduce_thresholds_table[range].numproc)) { 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_Allreduce_function + inter_leader[range_threshold].MV2_pt_Allreducection == &MPIR_Allreduce_mcst_reduce_redscat_gather_MV2) || (mv2_allreduce_thresholds_table[range]. - inter_leader[range_threshold].MV2_pt_Allreduce_function + inter_leader[range_threshold].MV2_pt_Allreducection == &MPIR_Allreduce_mcst_reduce_two_level_helper_MV2) )) { range_threshold++; @@ -393,8 +376,8 @@ int smpi_coll_tuned_allreduce_mvapich2(void *sendbuf, && (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 < @@ -406,37 +389,37 @@ int smpi_coll_tuned_allreduce_mvapich2(void *sendbuf, range_threshold_intra++; } - MV2_Allreduce_function = mv2_allreduce_thresholds_table[range].inter_leader[range_threshold] - .MV2_pt_Allreduce_function; + MV2_Allreducection = mv2_allreduce_thresholds_table[range].inter_leader[range_threshold] + .MV2_pt_Allreducection; MV2_Allreduce_intra_function = mv2_allreduce_thresholds_table[range].intra_node[range_threshold_intra] - .MV2_pt_Allreduce_function; + .MV2_pt_Allreducection; /* check if mcast is ready, otherwise replace mcast with other algorithm */ - if((MV2_Allreduce_function == &MPIR_Allreduce_mcst_reduce_redscat_gather_MV2)|| - (MV2_Allreduce_function == &MPIR_Allreduce_mcst_reduce_two_level_helper_MV2)){ + if((MV2_Allreducection == &MPIR_Allreduce_mcst_reduce_redscat_gather_MV2)|| + (MV2_Allreducection == &MPIR_Allreduce_mcst_reduce_two_level_helper_MV2)){ { - MV2_Allreduce_function = &MPIR_Allreduce_pt2pt_rd_MV2; + MV2_Allreducection = &MPIR_Allreduce_pt2pt_rd_MV2; } - if(is_two_level != 1) { - MV2_Allreduce_function = &MPIR_Allreduce_pt2pt_rd_MV2; + 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(smpi_comm_get_leaders_comm(comm)==MPI_COMM_NULL){ - smpi_comm_init_smp(comm); + 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_Allreduce_function(sendbuf, recvbuf, count, + mpi_errno = MV2_Allreducection(sendbuf, recvbuf, count, datatype, op, comm); } } @@ -449,71 +432,70 @@ int smpi_coll_tuned_allreduce_mvapich2(void *sendbuf, } -int smpi_coll_tuned_alltoallv_mvapich2(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 smpi_coll_tuned_alltoallv_ompi_basic_linear(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 smpi_coll_tuned_alltoallv_ring(sbuf, scounts, sdisps, sdtype, - rbuf, rcounts, rdisps,rdtype, - comm); + return alltoallv__ring(sbuf, scounts, sdisps, sdtype, + rbuf, rcounts, rdisps, rdtype, + comm); } -int smpi_coll_tuned_barrier_mvapich2(MPI_Comm comm) -{ - return smpi_coll_tuned_barrier_mvapich2_pair(comm); +int barrier__mvapich2(MPI_Comm comm) +{ + return barrier__mvapich2_pair(comm); } -int smpi_coll_tuned_bcast_mvapich2(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; - long nbytes = 0; + 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; if (count == 0) return MPI_SUCCESS; - if(smpi_comm_get_leaders_comm(comm)==MPI_COMM_NULL){ - smpi_comm_init_smp(comm); + if(comm->get_leaders_comm()==MPI_COMM_NULL){ + comm->init_smp(); } - if(!mv2_bcast_thresholds_table) + if (not mv2_bcast_thresholds_table) init_mv2_bcast_tables_stampede(); - comm_size = smpi_comm_size(comm); - //rank = smpi_comm_rank(comm); + 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, @@ -523,7 +505,7 @@ int smpi_coll_tuned_bcast_mvapich2(void *buffer, * possible, and MPI_Pack_size() in other places. */ //if (is_homogeneous) { - type_size=smpi_datatype_size(datatype); + type_size=datatype->size(); /* } else { MPIR_Pack_size_impl(1, datatype, &type_size); @@ -568,7 +550,7 @@ int smpi_coll_tuned_bcast_mvapich2(void *buffer, if (mv2_bcast_thresholds_table[range].inter_leader[range_threshold]. zcpy_pipelined_knomial_factor != -1) { - zcpy_knomial_factor = + zcpy_knomial_factor = mv2_bcast_thresholds_table[range].inter_leader[range_threshold]. zcpy_pipelined_knomial_factor; } @@ -585,7 +567,7 @@ int smpi_coll_tuned_bcast_mvapich2(void *buffer, /* Set value of pipeline segment size */ bcast_segment_size = mv2_bcast_thresholds_table[range].bcast_segment_size; - + /* Set value of inter node knomial factor */ mv2_inter_node_knomial_factor = mv2_bcast_thresholds_table[range].inter_node_knomial_factor; @@ -595,14 +577,14 @@ int smpi_coll_tuned_bcast_mvapich2(void *buffer, /* Check if we will use a two level algorithm or not */ two_level_bcast = #if defined(_MCST_SUPPORT_) - mv2_bcast_thresholds_table[range].is_two_level_bcast[range_threshold] + mv2_bcast_thresholds_table[range].is_two_level_bcast[range_threshold] || comm->ch.is_mcast_ok; #else mv2_bcast_thresholds_table[range].is_two_level_bcast[range_threshold]; #endif - if (two_level_bcast == 1) { - if (!is_contig || !is_homogeneous) { - tmp_buf=(void *)smpi_get_tmp_sendbuffer(nbytes); + if (two_level_bcast) { + // if (not is_contig || not is_homogeneous) { +// tmp_buf = smpi_get_tmp_sendbuffer(nbytes); /* position = 0;*/ /* if (rank == root) {*/ @@ -611,53 +593,46 @@ int smpi_coll_tuned_bcast_mvapich2(void *buffer, /* 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)) { - if (!is_contig || !is_homogeneous) { - mpi_errno = MPIR_Pipelined_Bcast_Zcpy_MV2(tmp_buf, nbytes, MPI_BYTE, - root, comm); - } else { + (&MPIR_Pipelined_Bcast_Zcpy_MV2 == MV2_Bcast_function)) { + // if (not is_contig || not is_homogeneous) { + // mpi_errno = MPIR_Pipelined_Bcast_Zcpy_MV2(tmp_buf, nbytes, MPI_BYTE, root, comm); + // } else { mpi_errno = MPIR_Pipelined_Bcast_Zcpy_MV2(buffer, count, datatype, root, comm); - } - } else + // } + } else #endif /* defined(CHANNEL_MRAIL_GEN2) */ - { - shmem_comm = smpi_comm_get_intra_comm(comm); - if (!is_contig || !is_homogeneous) { - mpi_errno = - MPIR_Bcast_tune_inter_node_helper_MV2(tmp_buf, nbytes, MPI_BYTE, - root, comm); - } else { - mpi_errno = - MPIR_Bcast_tune_inter_node_helper_MV2(buffer, count, datatype, root, - comm); - } + { + shmem_comm = comm->get_intra_comm(); + // if (not is_contig || not is_homogeneous) { + // MPIR_Bcast_tune_inter_node_helper_MV2(tmp_buf, nbytes, MPI_BYTE, root, comm); + // } else { + MPIR_Bcast_tune_inter_node_helper_MV2(buffer, count, datatype, root, comm); + // } /* We are now done with the inter-node phase */ root = INTRA_NODE_ROOT; - - if (!is_contig || !is_homogeneous) { - mpi_errno = MV2_Bcast_intra_node_function(tmp_buf, nbytes, - MPI_BYTE, root, shmem_comm); - } else { + // if (not is_contig || not is_homogeneous) { + // mpi_errno = MV2_Bcast_intra_node_function(tmp_buf, nbytes, MPI_BYTE, root, shmem_comm); + // } else { mpi_errno = MV2_Bcast_intra_node_function(buffer, count, datatype, root, shmem_comm); - } - } -/* if (!is_contig || !is_homogeneous) {*/ -/* if (rank != root) {*/ -/* position = 0;*/ -/* mpi_errno = MPIR_Unpack_impl(tmp_buf, nbytes, &position, buffer,*/ -/* count, datatype);*/ -/* }*/ -/* }*/ + // } + } + /* if (not is_contig || not is_homogeneous) {*/ + /* if (rank != root) {*/ + /* position = 0;*/ + /* mpi_errno = MPIR_Unpack_impl(tmp_buf, nbytes, &position, buffer,*/ + /* count, datatype);*/ + /* }*/ + /* }*/ } else { /* We use Knomial for intra node */ MV2_Bcast_intra_node_function = &MPIR_Knomial_Bcast_intra_node_MV2; @@ -678,7 +653,7 @@ int smpi_coll_tuned_bcast_mvapich2(void *buffer, -int smpi_coll_tuned_reduce_mvapich2( void *sendbuf, +int reduce__mvapich2(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, @@ -691,20 +666,20 @@ int smpi_coll_tuned_reduce_mvapich2( void *sendbuf, 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 = smpi_comm_size(comm); - sendtype_size=smpi_datatype_size(datatype); + comm_size = comm->size(); + sendtype_size=datatype->size(); nbytes = count * sendtype_size; if (count == 0) return MPI_SUCCESS; - is_commutative = smpi_op_is_commute(op); + 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 ); @@ -751,26 +726,25 @@ int smpi_coll_tuned_reduce_mvapich2( void *sendbuf, { 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(smpi_comm_get_leaders_comm(comm)==MPI_COMM_NULL){ - smpi_comm_init_smp(comm); + 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, + 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, + mpi_errno = MV2_Reduce_function(sendbuf, recvbuf, count, datatype, op, root, comm); } else { mpi_errno = MPIR_Reduce_binomial_MV2(sendbuf, recvbuf, count, @@ -779,14 +753,14 @@ int smpi_coll_tuned_reduce_mvapich2( void *sendbuf, } else if(MV2_Reduce_function == &MPIR_Reduce_redscat_gather_MV2){ if (/*(HANDLE_GET_KIND(op) == HANDLE_KIND_BUILTIN) &&*/ (count >= pof2)) { - mpi_errno = MV2_Reduce_function(sendbuf, recvbuf, count, + mpi_errno = MV2_Reduce_function(sendbuf, recvbuf, count, datatype, op, root, comm); } else { mpi_errno = MPIR_Reduce_binomial_MV2(sendbuf, recvbuf, count, datatype, op, root, comm); } } else { - mpi_errno = MV2_Reduce_function(sendbuf, recvbuf, count, + mpi_errno = MV2_Reduce_function(sendbuf, recvbuf, count, datatype, op, root, comm); } @@ -796,31 +770,30 @@ int smpi_coll_tuned_reduce_mvapich2( void *sendbuf, } -int smpi_coll_tuned_reduce_scatter_mvapich2(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 = smpi_comm_size(comm), total_count = 0, type_size = + int i = 0, comm_size = comm->size(), total_count = 0, type_size = 0, nbytes = 0; - int range = 0; - int range_threshold = 0; - int is_commutative = 0; - int *disps = static_cast(xbt_malloc(comm_size * sizeof (int))); + int* disps = new int[comm_size]; if(mv2_red_scat_thresholds_table==NULL) init_mv2_reduce_scatter_tables_stampede(); - is_commutative=smpi_op_is_commute(op); + 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]; } - type_size=smpi_datatype_size(datatype); + type_size=datatype->size(); nbytes = total_count * type_size; if (is_commutative) { + int range = 0; + int range_threshold = 0; /* Search for the corresponding system size inside the tuning table */ while ((range < (mv2_size_red_scat_tuning_table - 1)) && @@ -845,10 +818,10 @@ int smpi_coll_tuned_reduce_scatter_mvapich2(void *sendbuf, void *recvbuf, int *r 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; } } @@ -856,22 +829,22 @@ int smpi_coll_tuned_reduce_scatter_mvapich2(void *sendbuf, void *recvbuf, int *r while (pof2 < comm_size) pof2 <<= 1; if (pof2 == comm_size && is_block_regular) { /* noncommutative, pof2 size, and block regular */ - mpi_errno = MPIR_Reduce_scatter_non_comm_MV2(sendbuf, recvbuf, + MPIR_Reduce_scatter_non_comm_MV2(sendbuf, recvbuf, recvcnts, datatype, op, comm); } - mpi_errno = smpi_coll_tuned_reduce_scatter_mpich_rdb(sendbuf, recvbuf, - recvcnts, datatype, - op, comm); + mpi_errno = reduce_scatter__mpich_rdb(sendbuf, recvbuf, + recvcnts, datatype, + op, comm); } - xbt_free(disps); + delete[] disps; return mpi_errno; } -int smpi_coll_tuned_scatter_mvapich2(void *sendbuf, +int scatter__mvapich2(const void *sendbuf, int sendcnt, MPI_Datatype sendtype, void *recvbuf, @@ -883,54 +856,51 @@ int smpi_coll_tuned_scatter_mvapich2(void *sendbuf, int mpi_errno = MPI_SUCCESS; // int mpi_errno_ret = MPI_SUCCESS; int rank, nbytes, comm_size; - int recvtype_size, sendtype_size; - int partial_sub_ok = 0; + bool partial_sub_ok = false; int conf_index = 0; - int local_size = -1; - int i; MPI_Comm shmem_comm; // MPID_Comm *shmem_commptr=NULL; if(mv2_scatter_thresholds_table==NULL) init_mv2_scatter_tables_stampede(); - if(smpi_comm_get_leaders_comm(comm)==MPI_COMM_NULL){ - smpi_comm_init_smp(comm); + if(comm->get_leaders_comm()==MPI_COMM_NULL){ + comm->init_smp(); } - - comm_size = smpi_comm_size(comm); - rank = smpi_comm_rank(comm); + comm_size = comm->size(); + + rank = comm->rank(); if (rank == root) { - sendtype_size=smpi_datatype_size(sendtype); - nbytes = sendcnt * sendtype_size; + int sendtype_size = sendtype->size(); + nbytes = sendcnt * sendtype_size; } else { - recvtype_size=smpi_datatype_size(recvtype); - nbytes = recvcnt * recvtype_size; + int recvtype_size = recvtype->size(); + nbytes = recvcnt * recvtype_size; } - - // check if safe to use partial subscription mode - if (smpi_comm_is_uniform(comm)) { - shmem_comm = smpi_comm_get_intra_comm(comm); - local_size = smpi_comm_size(shmem_comm); - i = 0; + // check if safe to use partial subscription mode + if (comm->is_uniform()) { + + shmem_comm = comm->get_intra_comm(); if (mv2_scatter_table_ppn_conf[0] == -1) { - // Indicating user defined tuning + // Indicating user defined tuning conf_index = 0; }else{ + int local_size = shmem_comm->size(); + int i = 0; do { if (local_size == mv2_scatter_table_ppn_conf[i]) { conf_index = i; - partial_sub_ok = 1; + partial_sub_ok = true; break; } i++; } while(i < mv2_scatter_num_ppn_conf); } } - - if (partial_sub_ok != 1) { + + if (not partial_sub_ok) { conf_index = 0; } @@ -977,12 +947,12 @@ int smpi_coll_tuned_scatter_mvapich2(void *sendbuf, /* Fallback! */ MV2_Scatter_function = &MPIR_Scatter_MV2_Binomial; } - } + } } if( (MV2_Scatter_function == &MPIR_Scatter_MV2_two_level_Direct) || (MV2_Scatter_function == &MPIR_Scatter_MV2_two_level_Binomial)) { - if( smpi_comm_is_blocked(comm)) { + if( comm->is_blocked()) { MV2_Scatter_intra_function = mv2_scatter_thresholds_table[conf_index][range].intra_node[range_threshold_intra] .MV2_pt_Scatter_function; @@ -1004,29 +974,32 @@ int smpi_coll_tuned_scatter_mvapich2(void *sendbuf, return (mpi_errno); } -void smpi_coll_cleanup_mvapich2(void){ -int i=0; -if(mv2_alltoall_thresholds_table) - xbt_free(mv2_alltoall_thresholds_table[i]); -xbt_free(mv2_alltoall_thresholds_table); -xbt_free(mv2_size_alltoall_tuning_table); -xbt_free(mv2_alltoall_table_ppn_conf); - -xbt_free(mv2_gather_thresholds_table); -if(mv2_allgather_thresholds_table) - xbt_free(mv2_allgather_thresholds_table[0]); -xbt_free(mv2_size_allgather_tuning_table); -xbt_free(mv2_allgather_table_ppn_conf); -xbt_free(mv2_allgather_thresholds_table); - -xbt_free(mv2_allgatherv_thresholds_table); -xbt_free(mv2_reduce_thresholds_table); -xbt_free(mv2_red_scat_thresholds_table); -xbt_free(mv2_allreduce_thresholds_table); -xbt_free(mv2_bcast_thresholds_table); -if(mv2_scatter_thresholds_table) - xbt_free(mv2_scatter_thresholds_table[0]); -xbt_free(mv2_scatter_thresholds_table); -xbt_free(mv2_size_scatter_tuning_table); -xbt_free(mv2_scatter_table_ppn_conf); +} +} + +void smpi_coll_cleanup_mvapich2() +{ + if (mv2_alltoall_thresholds_table) + delete[] mv2_alltoall_thresholds_table[0]; + delete[] mv2_alltoall_thresholds_table; + delete[] mv2_size_alltoall_tuning_table; + delete[] mv2_alltoall_table_ppn_conf; + + delete[] mv2_gather_thresholds_table; + if (mv2_allgather_thresholds_table) + delete[] mv2_allgather_thresholds_table[0]; + delete[] mv2_size_allgather_tuning_table; + delete[] mv2_allgather_table_ppn_conf; + delete[] mv2_allgather_thresholds_table; + + delete[] mv2_allgatherv_thresholds_table; + delete[] mv2_reduce_thresholds_table; + delete[] mv2_red_scat_thresholds_table; + delete[] mv2_allreduce_thresholds_table; + delete[] mv2_bcast_thresholds_table; + if (mv2_scatter_thresholds_table) + delete[] mv2_scatter_thresholds_table[0]; + delete[] mv2_scatter_thresholds_table; + delete[] mv2_size_scatter_tuning_table; + delete[] mv2_scatter_table_ppn_conf; }