/* selector for collective algorithms based on mvapich decision logic */
-/* Copyright (c) 2009-2010, 2013-2017. The SimGrid Team.
+/* Copyright (c) 2009-2019. 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{
||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 = Datatype::copy((char *)recvbuf,
+ Datatype::copy((char *)recvbuf,
comm_size*recvcount, recvtype,
(char *)tmp_buf,
comm_size*recvcount, recvtype);
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->init_smp();
}
- int i;
if (comm->is_uniform()){
shmem_comm = comm->get_intra_comm();
- local_size = shmem_comm->size();
- i = 0;
+ int local_size = shmem_comm->size();
+ int i = 0;
if (mv2_allgather_table_ppn_conf[0] == -1) {
// Indicating user defined tuning
conf_index = 0;
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 = comm->size();
- rank = comm->rank();
+ int comm_size = comm->size();
+ int rank = comm->rank();
if (rank == root) {
- recvtype_size=recvtype->size();
- nbytes = recvcnt * recvtype_size;
+ int recvtype_size = recvtype->size();
+ nbytes = recvcnt * recvtype_size;
} else {
- sendtype_size=sendtype->size();
- nbytes = sendcnt * sendtype_size;
+ int sendtype_size = sendtype->size();
+ nbytes = sendcnt * sendtype_size;
}
/* Search for the corresponding system size inside the tuning table */
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;
nbytes = count * sendtype_size;
datatype->extent(&true_lb, &true_extent);
- //MPI_Op *op_ptr;
- //is_commutative = op->is_commutative();
+ is_commutative = op->is_commutative();
{
+ int range = 0, range_threshold = 0, range_threshold_intra = 0;
+ int is_two_level = 0;
+
/* 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)) {
int range = 0;
int range_threshold = 0;
int range_threshold_intra = 0;
- int is_homogeneous, is_contig;
+ // int is_homogeneous, is_contig;
MPI_Aint type_size;
//, position;
- void *tmp_buf = NULL;
+ // void *tmp_buf = NULL;
MPI_Comm shmem_comm;
//MPID_Datatype *dtp;
comm_size = comm->size();
//rank = comm->rank();
- is_contig=1;
+ //is_contig=1;
/* if (HANDLE_GET_KIND(datatype) == HANDLE_KIND_BUILTIN)*/
/* is_contig = 1;*/
/* else {*/
/* is_contig = dtp->is_contig;*/
/* }*/
- is_homogeneous = 1;
+ // is_homogeneous = 1;
/* MPI_Type_size() might not give the accurate size of the packed
* datatype for heterogeneous systems (because of padding, encoding,
mv2_bcast_thresholds_table[range].is_two_level_bcast[range_threshold];
#endif
if (two_level_bcast == 1) {
- if (not is_contig || not is_homogeneous) {
- tmp_buf = (void*)smpi_get_tmp_sendbuffer(nbytes);
+ // if (not is_contig || not is_homogeneous) {
+ // tmp_buf = (void*)smpi_get_tmp_sendbuffer(nbytes);
/* position = 0;*/
/* if (rank == root) {*/
/* 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 (not is_contig || not is_homogeneous) {
- mpi_errno = MPIR_Pipelined_Bcast_Zcpy_MV2(tmp_buf, nbytes, MPI_BYTE, root, comm);
- } else {
+ // 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
#endif /* defined(CHANNEL_MRAIL_GEN2) */
{
shmem_comm = comm->get_intra_comm();
- if (not is_contig || not 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);
- }
+ // 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 (not is_contig || not 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 (not is_contig || not is_homogeneous) {*/
/* if (rank != root) {*/
int mpi_errno = MPI_SUCCESS;
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<int*>(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();
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)) &&
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);
}
recvcnts, datatype,
op, comm);
}
- xbt_free(disps);
+ delete[] disps;
return mpi_errno;
}
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;
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)
rank = comm->rank();
if (rank == root) {
- sendtype_size=sendtype->size();
- nbytes = sendcnt * sendtype_size;
+ int sendtype_size = sendtype->size();
+ nbytes = sendcnt * sendtype_size;
} else {
- recvtype_size=recvtype->size();
- nbytes = recvcnt * recvtype_size;
+ int recvtype_size = recvtype->size();
+ nbytes = recvcnt * recvtype_size;
}
// check if safe to use partial subscription mode
if (comm->is_uniform()) {
shmem_comm = comm->get_intra_comm();
- local_size = shmem_comm->size();
- i = 0;
if (mv2_scatter_table_ppn_conf[0] == -1) {
// 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;
void smpi_coll_cleanup_mvapich2()
{
- 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);
+ delete[] mv2_alltoall_thresholds_table[0];
+ delete[] mv2_alltoall_thresholds_table;
+ delete[] mv2_size_alltoall_tuning_table;
+ delete[] mv2_alltoall_table_ppn_conf;
- xbt_free(mv2_gather_thresholds_table);
+ delete[] 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);
+ 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)
- 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);
+ delete[] mv2_scatter_thresholds_table[0];
+ delete[] mv2_scatter_thresholds_table;
+ delete[] mv2_size_scatter_tuning_table;
+ delete[] mv2_scatter_table_ppn_conf;
}