#include "smpi_mvapich2_selector_stampede.h"
+namespace simgrid{
+namespace smpi{
-int smpi_coll_tuned_alltoall_mvapich2( void *sendbuf, int sendcount,
+
+int Coll_alltoall_mvapich2::alltoall( void *sendbuf, int sendcount,
MPI_Datatype sendtype,
void* recvbuf, int recvcount,
MPI_Datatype recvtype,
int conf_index = 0;
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 */
||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,
+ mpi_errno = Datatype::copy((char *)recvbuf,
comm_size*recvcount, recvtype,
(char *)tmp_buf,
comm_size*recvcount, recvtype);
return (mpi_errno);
}
-int smpi_coll_tuned_allgather_mvapich2(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+int Coll_allgather_mvapich2::allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
void *recvbuf, int recvcount, MPI_Datatype recvtype,
MPI_Comm comm)
{
//MPI_Comm *shmem_commptr=NULL;
/* Get the size of the communicator */
comm_size = comm->size();
- recvtype_size=smpi_datatype_size(recvtype);
+ recvtype_size=recvtype->size();
nbytes = recvtype_size * recvcount;
if(mv2_allgather_table_ppn_conf==NULL)
}
/* 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];
recvbuf, recvcount, recvtype,
comm);
}else{
- mpi_errno = smpi_coll_tuned_allgather_mpich(sendbuf, sendcount, sendtype,
+ mpi_errno = Coll_allgather_mpich::allgather(sendbuf, sendcount, sendtype,
recvbuf, recvcount, recvtype,
comm);
}
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{
return mpi_errno;
}
-
-int smpi_coll_tuned_gather_mvapich2(void *sendbuf,
+int Coll_gather_mvapich2::gather(void *sendbuf,
int sendcnt,
MPI_Datatype sendtype,
void *recvbuf,
rank = comm->rank();
if (rank == root) {
- recvtype_size=smpi_datatype_size(recvtype);
+ recvtype_size=recvtype->size();
nbytes = recvcnt * recvtype_size;
} else {
- sendtype_size=smpi_datatype_size(sendtype);
+ sendtype_size=sendtype->size();
nbytes = sendcnt * sendtype_size;
}
} else {
// Indeed, direct (non SMP-aware)gather is MPICH one
- mpi_errno = smpi_coll_tuned_gather_mpich(sendbuf, sendcnt, sendtype,
+ mpi_errno = Coll_gather_mpich::gather(sendbuf, sendcnt, sendtype,
recvbuf, recvcnt, recvtype,
root, comm);
}
return mpi_errno;
}
-
-int smpi_coll_tuned_allgatherv_mvapich2(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+int Coll_allgatherv_mvapich2::allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
void *recvbuf, int *recvcounts, int *displs,
MPI_Datatype recvtype, MPI_Comm comm )
{
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 */
-int smpi_coll_tuned_allreduce_mvapich2(void *sendbuf,
+int Coll_allreduce_mvapich2::allreduce(void *sendbuf,
void *recvbuf,
int count,
MPI_Datatype datatype,
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);
+ datatype->extent(&true_lb, &true_extent);
//MPI_Op *op_ptr;
//is_commutative = op->is_commutative();
if(mv2_allreduce_thresholds_table[range].mcast_enabled != 1){
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++;
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;
+ MV2_Allreducection = &MPIR_Allreduce_pt2pt_rd_MV2;
}
}
datatype, op, comm);
}
} else {
- mpi_errno = MV2_Allreduce_function(sendbuf, recvbuf, count,
+ mpi_errno = MV2_Allreducection(sendbuf, recvbuf, count,
datatype, op, comm);
}
}
}
-int smpi_coll_tuned_alltoallv_mvapich2(void *sbuf, int *scounts, int *sdisps,
+int Coll_alltoallv_mvapich2::alltoallv(void *sbuf, int *scounts, int *sdisps,
MPI_Datatype sdtype,
void *rbuf, int *rcounts, int *rdisps,
MPI_Datatype rdtype,
{
if (sbuf == MPI_IN_PLACE) {
- return smpi_coll_tuned_alltoallv_ompi_basic_linear(sbuf, scounts, sdisps, sdtype,
+ return Coll_alltoallv_ompi_basic_linear::alltoallv(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,
+ return Coll_alltoallv_ring::alltoallv(sbuf, scounts, sdisps, sdtype,
rbuf, rcounts, rdisps,rdtype,
comm);
}
-int smpi_coll_tuned_barrier_mvapich2(MPI_Comm comm)
+int Coll_barrier_mvapich2::barrier(MPI_Comm comm)
{
- return smpi_coll_tuned_barrier_mvapich2_pair(comm);
+ return Coll_barrier_mvapich2_pair::barrier(comm);
}
-int smpi_coll_tuned_bcast_mvapich2(void *buffer,
+int Coll_bcast_mvapich2::bcast(void *buffer,
int count,
MPI_Datatype datatype,
int root, MPI_Comm comm)
* 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);
-int smpi_coll_tuned_reduce_mvapich2( void *sendbuf,
+int Coll_reduce_mvapich2::reduce( void *sendbuf,
void *recvbuf,
int count,
MPI_Datatype datatype,
int is_two_level = 0;
comm_size = comm->size();
- sendtype_size=smpi_datatype_size(datatype);
+ sendtype_size=datatype->size();
nbytes = count * sendtype_size;
if (count == 0)
}
-int smpi_coll_tuned_reduce_scatter_mvapich2(void *sendbuf, void *recvbuf, int *recvcnts,
+int Coll_reduce_scatter_mvapich2::reduce_scatter(void *sendbuf, void *recvbuf, int *recvcnts,
MPI_Datatype datatype, MPI_Op op,
MPI_Comm comm)
{
total_count += recvcnts[i];
}
- type_size=smpi_datatype_size(datatype);
+ type_size=datatype->size();
nbytes = total_count * type_size;
if (is_commutative) {
recvcnts, datatype,
op, comm);
}
- mpi_errno = smpi_coll_tuned_reduce_scatter_mpich_rdb(sendbuf, recvbuf,
+ mpi_errno = Coll_reduce_scatter_mpich_rdb::reduce_scatter(sendbuf, recvbuf,
recvcnts, datatype,
op, comm);
}
-int smpi_coll_tuned_scatter_mvapich2(void *sendbuf,
+int Coll_scatter_mvapich2::scatter(void *sendbuf,
int sendcnt,
MPI_Datatype sendtype,
void *recvbuf,
rank = comm->rank();
if (rank == root) {
- sendtype_size=smpi_datatype_size(sendtype);
+ sendtype_size=sendtype->size();
nbytes = sendcnt * sendtype_size;
} else {
- recvtype_size=smpi_datatype_size(recvtype);
+ recvtype_size=recvtype->size();
nbytes = recvcnt * recvtype_size;
}
return (mpi_errno);
}
+}
+}
void smpi_coll_cleanup_mvapich2(void){
int i=0;
if(mv2_alltoall_thresholds_table)
