diff --git a/ompi/mca/coll/basic/coll_basic.h b/ompi/mca/coll/basic/coll_basic.h index 5ee9f854f1..63a7bab727 100644 --- a/ompi/mca/coll/basic/coll_basic.h +++ b/ompi/mca/coll/basic/coll_basic.h @@ -35,7 +35,7 @@ extern "C" */ OMPI_COMP_EXPORT extern const mca_coll_base_component_1_0_0_t - mca_coll_basic_component; + mca_coll_basic_component; OMPI_COMP_EXPORT extern int mca_coll_basic_priority_param; @@ -47,89 +47,89 @@ extern "C" /* API functions */ int mca_coll_basic_init_query(bool enable_progress_threads, - bool enable_mpi_threads); + bool enable_mpi_threads); const struct mca_coll_base_module_1_0_0_t - *mca_coll_basic_comm_query(struct ompi_communicator_t *comm, - int *priority, - struct mca_coll_base_comm_t **data); + *mca_coll_basic_comm_query(struct ompi_communicator_t *comm, + int *priority, + struct mca_coll_base_comm_t **data); const struct mca_coll_base_module_1_0_0_t - *mca_coll_basic_module_init(struct ompi_communicator_t *comm); + *mca_coll_basic_module_init(struct ompi_communicator_t *comm); int mca_coll_basic_module_finalize(struct ompi_communicator_t *comm); int mca_coll_basic_allgather_intra(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm); int mca_coll_basic_allgather_inter(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm); int mca_coll_basic_allgatherv_intra(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, - int *disps, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, + int *disps, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm); int mca_coll_basic_allgatherv_inter(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, - int *disps, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, + int *disps, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm); int mca_coll_basic_allreduce_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm); int mca_coll_basic_allreduce_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm); int mca_coll_basic_alltoall_intra(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm); int mca_coll_basic_alltoall_inter(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm); int mca_coll_basic_alltoallv_intra(void *sbuf, int *scounts, - int *sdisps, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, - int *rdisps, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm); + int *sdisps, + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, + int *rdisps, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm); int mca_coll_basic_alltoallv_inter(void *sbuf, int *scounts, - int *sdisps, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, - int *rdisps, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm); + int *sdisps, + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, + int *rdisps, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm); int mca_coll_basic_alltoallw_intra(void *sbuf, int *scounts, - int *sdisps, - struct ompi_datatype_t **sdtypes, - void *rbuf, int *rcounts, - int *rdisps, - struct ompi_datatype_t **rdtypes, - struct ompi_communicator_t *comm); + int *sdisps, + struct ompi_datatype_t **sdtypes, + void *rbuf, int *rcounts, + int *rdisps, + struct ompi_datatype_t **rdtypes, + struct ompi_communicator_t *comm); int mca_coll_basic_alltoallw_inter(void *sbuf, int *scounts, - int *sdisps, - struct ompi_datatype_t **sdtypes, - void *rbuf, int *rcounts, - int *rdisps, - struct ompi_datatype_t **rdtypes, - struct ompi_communicator_t *comm); + int *sdisps, + struct ompi_datatype_t **sdtypes, + void *rbuf, int *rcounts, + int *rdisps, + struct ompi_datatype_t **rdtypes, + struct ompi_communicator_t *comm); int mca_coll_basic_barrier_intra_lin(struct ompi_communicator_t *comm); int mca_coll_basic_barrier_inter_lin(struct ompi_communicator_t *comm); @@ -137,138 +137,138 @@ extern "C" int mca_coll_basic_barrier_intra_log(struct ompi_communicator_t *comm); int mca_coll_basic_bcast_lin_intra(void *buff, int count, - struct ompi_datatype_t *datatype, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *datatype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_bcast_lin_inter(void *buff, int count, - struct ompi_datatype_t *datatype, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *datatype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_bcast_log_intra(void *buff, int count, - struct ompi_datatype_t *datatype, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *datatype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_bcast_log_inter(void *buff, int count, - struct ompi_datatype_t *datatype, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *datatype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_exscan_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm); int mca_coll_basic_exscan_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm); int mca_coll_basic_gather_intra(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); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_gather_inter(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); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_gatherv_intra(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *disps, - struct ompi_datatype_t *rdtype, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, int *disps, + struct ompi_datatype_t *rdtype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_gatherv_inter(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *disps, - struct ompi_datatype_t *rdtype, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, int *disps, + struct ompi_datatype_t *rdtype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_reduce_lin_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_reduce_lin_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_reduce_log_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_reduce_log_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_reduce_scatter_intra(void *sbuf, void *rbuf, - int *rcounts, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t - *comm); + int *rcounts, + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t + *comm); int mca_coll_basic_reduce_scatter_inter(void *sbuf, void *rbuf, - int *rcounts, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t - *comm); + int *rcounts, + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t + *comm); int mca_coll_basic_scan_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm); int mca_coll_basic_scan_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm); int mca_coll_basic_scatter_intra(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); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_scatter_inter(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); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_scatterv_intra(void *sbuf, int *scounts, int *disps, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + int root, + struct ompi_communicator_t *comm); int mca_coll_basic_scatterv_inter(void *sbuf, int *scounts, int *disps, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - int root, - struct ompi_communicator_t *comm); + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + int root, + struct ompi_communicator_t *comm); /* Utility functions */ static inline void mca_coll_basic_free_reqs(ompi_request_t ** reqs, - int count) + int count) { - int i; - for (i = 0; i < count; ++i) - ompi_request_free(&reqs[i]); + int i; + for (i = 0; i < count; ++i) + ompi_request_free(&reqs[i]); } @@ -277,8 +277,8 @@ extern "C" */ struct mca_coll_base_comm_t { - ompi_request_t **mccb_reqs; - int mccb_num_reqs; + ompi_request_t **mccb_reqs; + int mccb_num_reqs; }; #if defined(c_plusplus) || defined(__cplusplus) diff --git a/ompi/mca/coll/basic/coll_basic_allgather.c b/ompi/mca/coll/basic/coll_basic_allgather.c index 9c3b09c964..203acaadbb 100644 --- a/ompi/mca/coll/basic/coll_basic_allgather.c +++ b/ompi/mca/coll/basic/coll_basic_allgather.c @@ -36,9 +36,9 @@ */ int mca_coll_basic_allgather_intra(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, void *rbuf, - int rcount, struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, void *rbuf, + int rcount, struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm) { int size; int err; @@ -48,9 +48,9 @@ mca_coll_basic_allgather_intra(void *sbuf, int scount, size = ompi_comm_size(comm); err = comm->c_coll.coll_gather(sbuf, scount, sdtype, rbuf, rcount, - rdtype, 0, comm); + rdtype, 0, comm); if (MPI_SUCCESS != err) - return err; + return err; err = comm->c_coll.coll_bcast(rbuf, rcount * size, rdtype, 0, comm); return err; @@ -66,10 +66,10 @@ mca_coll_basic_allgather_intra(void *sbuf, int scount, */ int mca_coll_basic_allgather_inter(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm) { int rank; int root = 0; @@ -95,80 +95,80 @@ mca_coll_basic_allgather_inter(void *sbuf, int scount, /* Step one: gather operations: */ if (rank != root) { - /* send your data to root */ - err = MCA_PML_CALL(send(sbuf, scount, sdtype, root, - MCA_COLL_BASE_TAG_ALLGATHER, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (OMPI_SUCCESS != err) { - return err; - } + /* send your data to root */ + err = MCA_PML_CALL(send(sbuf, scount, sdtype, root, + MCA_COLL_BASE_TAG_ALLGATHER, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (OMPI_SUCCESS != err) { + return err; + } } else { - /* receive a msg. from all other procs. */ - err = ompi_ddt_get_extent(rdtype, &rlb, &rextent); - if (OMPI_SUCCESS != err) { - return err; - } - err = ompi_ddt_get_extent(sdtype, &slb, &sextent); - if (OMPI_SUCCESS != err) { - return err; - } + /* receive a msg. from all other procs. */ + err = ompi_ddt_get_extent(rdtype, &rlb, &rextent); + if (OMPI_SUCCESS != err) { + return err; + } + err = ompi_ddt_get_extent(sdtype, &slb, &sextent); + if (OMPI_SUCCESS != err) { + return err; + } - /* Do a send-recv between the two root procs. to avoid deadlock */ - err = MCA_PML_CALL(isend(sbuf, scount, sdtype, 0, - MCA_COLL_BASE_TAG_ALLGATHER, - MCA_PML_BASE_SEND_STANDARD, - comm, &reqs[rsize])); - if (OMPI_SUCCESS != err) { - return err; - } + /* Do a send-recv between the two root procs. to avoid deadlock */ + err = MCA_PML_CALL(isend(sbuf, scount, sdtype, 0, + MCA_COLL_BASE_TAG_ALLGATHER, + MCA_PML_BASE_SEND_STANDARD, + comm, &reqs[rsize])); + if (OMPI_SUCCESS != err) { + return err; + } - err = MCA_PML_CALL(irecv(rbuf, rcount, rdtype, 0, - MCA_COLL_BASE_TAG_ALLGATHER, comm, - &reqs[0])); - if (OMPI_SUCCESS != err) { - return err; - } + err = MCA_PML_CALL(irecv(rbuf, rcount, rdtype, 0, + MCA_COLL_BASE_TAG_ALLGATHER, comm, + &reqs[0])); + if (OMPI_SUCCESS != err) { + return err; + } - incr = rextent * rcount; - ptmp = (char *) rbuf + incr; - for (i = 1; i < rsize; ++i, ptmp += incr) { - err = MCA_PML_CALL(irecv(ptmp, rcount, rdtype, i, - MCA_COLL_BASE_TAG_ALLGATHER, - comm, &reqs[i])); - if (MPI_SUCCESS != err) { - return err; - } - } + incr = rextent * rcount; + ptmp = (char *) rbuf + incr; + for (i = 1; i < rsize; ++i, ptmp += incr) { + err = MCA_PML_CALL(irecv(ptmp, rcount, rdtype, i, + MCA_COLL_BASE_TAG_ALLGATHER, + comm, &reqs[i])); + if (MPI_SUCCESS != err) { + return err; + } + } - err = ompi_request_wait_all(rsize + 1, reqs, MPI_STATUSES_IGNORE); - if (OMPI_SUCCESS != err) { - return err; - } + err = ompi_request_wait_all(rsize + 1, reqs, MPI_STATUSES_IGNORE); + if (OMPI_SUCCESS != err) { + return err; + } - /* Step 2: exchange the resuts between the root processes */ - tmpbuf = (char *) malloc(scount * size * sextent); - if (NULL == tmpbuf) { - return err; - } + /* Step 2: exchange the resuts between the root processes */ + tmpbuf = (char *) malloc(scount * size * sextent); + if (NULL == tmpbuf) { + return err; + } - err = MCA_PML_CALL(isend(rbuf, rsize * rcount, rdtype, 0, - MCA_COLL_BASE_TAG_ALLGATHER, - MCA_PML_BASE_SEND_STANDARD, comm, &req)); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = MCA_PML_CALL(isend(rbuf, rsize * rcount, rdtype, 0, + MCA_COLL_BASE_TAG_ALLGATHER, + MCA_PML_BASE_SEND_STANDARD, comm, &req)); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = MCA_PML_CALL(recv(tmpbuf, size * scount, sdtype, 0, - MCA_COLL_BASE_TAG_ALLGATHER, comm, - MPI_STATUS_IGNORE)); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = MCA_PML_CALL(recv(tmpbuf, size * scount, sdtype, 0, + MCA_COLL_BASE_TAG_ALLGATHER, comm, + MPI_STATUS_IGNORE)); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = ompi_request_wait_all(1, &req, MPI_STATUS_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = ompi_request_wait_all(1, &req, MPI_STATUS_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } } @@ -177,35 +177,35 @@ mca_coll_basic_allgather_inter(void *sbuf, int scount, * not use coll_bcast (this would deadlock). */ if (rank != root) { - /* post the recv */ - err = MCA_PML_CALL(recv(rbuf, size * rcount, rdtype, 0, - MCA_COLL_BASE_TAG_ALLGATHER, comm, - MPI_STATUS_IGNORE)); - if (OMPI_SUCCESS != err) { - goto exit; - } + /* post the recv */ + err = MCA_PML_CALL(recv(rbuf, size * rcount, rdtype, 0, + MCA_COLL_BASE_TAG_ALLGATHER, comm, + MPI_STATUS_IGNORE)); + if (OMPI_SUCCESS != err) { + goto exit; + } } else { - /* Send the data to every other process in the remote group - * except to rank zero. which has it already. */ - for (i = 1; i < rsize; i++) { - err = MCA_PML_CALL(isend(tmpbuf, size * scount, sdtype, i, - MCA_COLL_BASE_TAG_ALLGATHER, - MCA_PML_BASE_SEND_STANDARD, - comm, &reqs[i - 1])); - if (OMPI_SUCCESS != err) { - goto exit; - } - } + /* Send the data to every other process in the remote group + * except to rank zero. which has it already. */ + for (i = 1; i < rsize; i++) { + err = MCA_PML_CALL(isend(tmpbuf, size * scount, sdtype, i, + MCA_COLL_BASE_TAG_ALLGATHER, + MCA_PML_BASE_SEND_STANDARD, + comm, &reqs[i - 1])); + if (OMPI_SUCCESS != err) { + goto exit; + } + } - err = ompi_request_wait_all(rsize - 1, reqs, MPI_STATUSES_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = ompi_request_wait_all(rsize - 1, reqs, MPI_STATUSES_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } } exit: if (NULL != tmpbuf) { - free(tmpbuf); + free(tmpbuf); } return err; diff --git a/ompi/mca/coll/basic/coll_basic_allgatherv.c b/ompi/mca/coll/basic/coll_basic_allgatherv.c index 002f295c68..162d7d8865 100644 --- a/ompi/mca/coll/basic/coll_basic_allgatherv.c +++ b/ompi/mca/coll/basic/coll_basic_allgatherv.c @@ -34,10 +34,10 @@ */ int mca_coll_basic_allgatherv_intra(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *disps, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, int *disps, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm) { int i, size; int err; @@ -66,10 +66,10 @@ mca_coll_basic_allgatherv_intra(void *sbuf, int scount, */ int mca_coll_basic_allgatherv_inter(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *disps, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, int *disps, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm) { int size, rsize; int err, i; @@ -82,21 +82,21 @@ mca_coll_basic_allgatherv_inter(void *sbuf, int scount, scounts = (int *) malloc(rsize * sizeof(int)); sdisps = (int *) calloc(rsize, sizeof(int)); if (NULL == scounts || NULL == sdisps) { - return OMPI_ERR_OUT_OF_RESOURCE; + return OMPI_ERR_OUT_OF_RESOURCE; } for (i = 0; i < rsize; i++) { - scounts[i] = scount; + scounts[i] = scount; } err = comm->c_coll.coll_alltoallv(sbuf, scounts, sdisps, sdtype, - rbuf, rcounts, disps, rdtype, comm); + rbuf, rcounts, disps, rdtype, comm); if (NULL != sdisps) { - free(sdisps); + free(sdisps); } if (NULL != scounts) { - free(scounts); + free(scounts); } return err; diff --git a/ompi/mca/coll/basic/coll_basic_allreduce.c b/ompi/mca/coll/basic/coll_basic_allreduce.c index 0cdb4693b7..ac8db7c7ac 100644 --- a/ompi/mca/coll/basic/coll_basic_allreduce.c +++ b/ompi/mca/coll/basic/coll_basic_allreduce.c @@ -37,9 +37,9 @@ */ int mca_coll_basic_allreduce_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm) { int err; @@ -47,7 +47,7 @@ mca_coll_basic_allreduce_intra(void *sbuf, void *rbuf, int count, err = comm->c_coll.coll_reduce(sbuf, rbuf, count, dtype, op, 0, comm); if (MPI_SUCCESS != err) { - return err; + return err; } return comm->c_coll.coll_bcast(rbuf, count, dtype, 0, comm); @@ -63,9 +63,9 @@ mca_coll_basic_allreduce_intra(void *sbuf, void *rbuf, int count, */ int mca_coll_basic_allreduce_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm) { int err, i; int rank; @@ -89,59 +89,59 @@ mca_coll_basic_allreduce_inter(void *sbuf, void *rbuf, int count, * simultaniously. */ /*****************************************************************/ if (rank == root) { - err = ompi_ddt_get_extent(dtype, &lb, &extent); - if (OMPI_SUCCESS != err) { - return OMPI_ERROR; - } + err = ompi_ddt_get_extent(dtype, &lb, &extent); + if (OMPI_SUCCESS != err) { + return OMPI_ERROR; + } - tmpbuf = (char *) malloc(count * extent); - if (NULL == tmpbuf) { - return OMPI_ERR_OUT_OF_RESOURCE; - } - pml_buffer = tmpbuf - lb; + tmpbuf = (char *) malloc(count * extent); + if (NULL == tmpbuf) { + return OMPI_ERR_OUT_OF_RESOURCE; + } + pml_buffer = tmpbuf - lb; - /* Do a send-recv between the two root procs. to avoid deadlock */ - err = MCA_PML_CALL(irecv(rbuf, count, dtype, 0, - MCA_COLL_BASE_TAG_ALLREDUCE, comm, - &(req[0]))); - if (OMPI_SUCCESS != err) { - goto exit; - } + /* Do a send-recv between the two root procs. to avoid deadlock */ + err = MCA_PML_CALL(irecv(rbuf, count, dtype, 0, + MCA_COLL_BASE_TAG_ALLREDUCE, comm, + &(req[0]))); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = MCA_PML_CALL(isend(sbuf, count, dtype, 0, - MCA_COLL_BASE_TAG_ALLREDUCE, - MCA_PML_BASE_SEND_STANDARD, - comm, &(req[1]))); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = MCA_PML_CALL(isend(sbuf, count, dtype, 0, + MCA_COLL_BASE_TAG_ALLREDUCE, + MCA_PML_BASE_SEND_STANDARD, + comm, &(req[1]))); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = ompi_request_wait_all(2, req, MPI_STATUSES_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = ompi_request_wait_all(2, req, MPI_STATUSES_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } - /* Loop receiving and calling reduction function (C or Fortran). */ - for (i = 1; i < rsize; i++) { - err = MCA_PML_CALL(recv(pml_buffer, count, dtype, i, - MCA_COLL_BASE_TAG_ALLREDUCE, comm, - MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - goto exit; - } + /* Loop receiving and calling reduction function (C or Fortran). */ + for (i = 1; i < rsize; i++) { + err = MCA_PML_CALL(recv(pml_buffer, count, dtype, i, + MCA_COLL_BASE_TAG_ALLREDUCE, comm, + MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + goto exit; + } - /* Perform the reduction */ - ompi_op_reduce(op, pml_buffer, rbuf, count, dtype); - } + /* Perform the reduction */ + ompi_op_reduce(op, pml_buffer, rbuf, count, dtype); + } } else { - /* If not root, send data to the root. */ - err = MCA_PML_CALL(send(sbuf, count, dtype, root, - MCA_COLL_BASE_TAG_ALLREDUCE, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (OMPI_SUCCESS != err) { - goto exit; - } + /* If not root, send data to the root. */ + err = MCA_PML_CALL(send(sbuf, count, dtype, root, + MCA_COLL_BASE_TAG_ALLREDUCE, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (OMPI_SUCCESS != err) { + goto exit; + } } @@ -151,58 +151,58 @@ mca_coll_basic_allreduce_inter(void *sbuf, void *rbuf, int count, * remote group. */ /***************************************************************************/ if (rank == root) { - /* sendrecv between the two roots */ - err = MCA_PML_CALL(irecv(pml_buffer, count, dtype, 0, - MCA_COLL_BASE_TAG_ALLREDUCE, - comm, &(req[1]))); - if (OMPI_SUCCESS != err) { - goto exit; - } + /* sendrecv between the two roots */ + err = MCA_PML_CALL(irecv(pml_buffer, count, dtype, 0, + MCA_COLL_BASE_TAG_ALLREDUCE, + comm, &(req[1]))); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = MCA_PML_CALL(isend(rbuf, count, dtype, 0, - MCA_COLL_BASE_TAG_ALLREDUCE, - MCA_PML_BASE_SEND_STANDARD, comm, - &(req[0]))); - if (OMPI_SUCCESS != err) { - goto exit; - } - err = ompi_request_wait_all(2, req, MPI_STATUSES_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = MCA_PML_CALL(isend(rbuf, count, dtype, 0, + MCA_COLL_BASE_TAG_ALLREDUCE, + MCA_PML_BASE_SEND_STANDARD, comm, + &(req[0]))); + if (OMPI_SUCCESS != err) { + goto exit; + } + err = ompi_request_wait_all(2, req, MPI_STATUSES_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } - /* distribute the data to other processes in remote group. - * Note that we start from 1 (not from zero), since zero - * has already the correct data AND we avoid a potential - * deadlock here. - */ - if (rsize > 1) { - for (i = 1; i < rsize; i++) { - err = MCA_PML_CALL(isend(pml_buffer, count, dtype, i, - MCA_COLL_BASE_TAG_ALLREDUCE, - MCA_PML_BASE_SEND_STANDARD, comm, - &reqs[i - 1])); - if (OMPI_SUCCESS != err) { - goto exit; - } - } + /* distribute the data to other processes in remote group. + * Note that we start from 1 (not from zero), since zero + * has already the correct data AND we avoid a potential + * deadlock here. + */ + if (rsize > 1) { + for (i = 1; i < rsize; i++) { + err = MCA_PML_CALL(isend(pml_buffer, count, dtype, i, + MCA_COLL_BASE_TAG_ALLREDUCE, + MCA_PML_BASE_SEND_STANDARD, comm, + &reqs[i - 1])); + if (OMPI_SUCCESS != err) { + goto exit; + } + } - err = - ompi_request_wait_all(rsize - 1, reqs, - MPI_STATUSES_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } - } + err = + ompi_request_wait_all(rsize - 1, reqs, + MPI_STATUSES_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } + } } else { - err = MCA_PML_CALL(recv(rbuf, count, dtype, root, - MCA_COLL_BASE_TAG_ALLREDUCE, - comm, MPI_STATUS_IGNORE)); + err = MCA_PML_CALL(recv(rbuf, count, dtype, root, + MCA_COLL_BASE_TAG_ALLREDUCE, + comm, MPI_STATUS_IGNORE)); } exit: if (NULL != tmpbuf) { - free(tmpbuf); + free(tmpbuf); } diff --git a/ompi/mca/coll/basic/coll_basic_alltoall.c b/ompi/mca/coll/basic/coll_basic_alltoall.c index 88d1458750..64090fc05e 100644 --- a/ompi/mca/coll/basic/coll_basic_alltoall.c +++ b/ompi/mca/coll/basic/coll_basic_alltoall.c @@ -35,10 +35,10 @@ */ int mca_coll_basic_alltoall_intra(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm) { int i; int rank; @@ -62,13 +62,13 @@ mca_coll_basic_alltoall_intra(void *sbuf, int scount, err = ompi_ddt_get_extent(sdtype, &lb, &sndinc); if (OMPI_SUCCESS != err) { - return err; + return err; } sndinc *= scount; err = ompi_ddt_get_extent(rdtype, &lb, &rcvinc); if (OMPI_SUCCESS != err) { - return err; + return err; } rcvinc *= rcount; @@ -79,13 +79,13 @@ mca_coll_basic_alltoall_intra(void *sbuf, int scount, err = ompi_ddt_sndrcv(psnd, scount, sdtype, prcv, rcount, rdtype); if (MPI_SUCCESS != err) { - return err; + return err; } /* If only one process, we're done. */ if (1 == size) { - return MPI_SUCCESS; + return MPI_SUCCESS; } /* Initiate all send/recv to/from others. */ @@ -100,28 +100,28 @@ mca_coll_basic_alltoall_intra(void *sbuf, int scount, /* Post all receives first -- a simple optimization */ for (i = (rank + 1) % size; i != rank; i = (i + 1) % size, ++rreq) { - err = - MCA_PML_CALL(irecv_init - (prcv + (i * rcvinc), rcount, rdtype, i, - MCA_COLL_BASE_TAG_ALLTOALL, comm, rreq)); - if (MPI_SUCCESS != err) { - mca_coll_basic_free_reqs(req, rreq - req); - return err; - } + err = + MCA_PML_CALL(irecv_init + (prcv + (i * rcvinc), rcount, rdtype, i, + MCA_COLL_BASE_TAG_ALLTOALL, comm, rreq)); + if (MPI_SUCCESS != err) { + mca_coll_basic_free_reqs(req, rreq - req); + return err; + } } /* Now post all sends */ for (i = (rank + 1) % size; i != rank; i = (i + 1) % size, ++sreq) { - err = - MCA_PML_CALL(isend_init - (psnd + (i * sndinc), scount, sdtype, i, - MCA_COLL_BASE_TAG_ALLTOALL, - MCA_PML_BASE_SEND_STANDARD, comm, sreq)); - if (MPI_SUCCESS != err) { - mca_coll_basic_free_reqs(req, sreq - req); - return err; - } + err = + MCA_PML_CALL(isend_init + (psnd + (i * sndinc), scount, sdtype, i, + MCA_COLL_BASE_TAG_ALLTOALL, + MCA_PML_BASE_SEND_STANDARD, comm, sreq)); + if (MPI_SUCCESS != err) { + mca_coll_basic_free_reqs(req, sreq - req); + return err; + } } /* Start your engines. This will never return an error. */ @@ -156,10 +156,10 @@ mca_coll_basic_alltoall_intra(void *sbuf, int scount, */ int mca_coll_basic_alltoall_inter(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm) { int i; int rank; @@ -183,13 +183,13 @@ mca_coll_basic_alltoall_inter(void *sbuf, int scount, err = ompi_ddt_get_extent(sdtype, &lb, &sndinc); if (OMPI_SUCCESS != err) { - return err; + return err; } sndinc *= scount; err = ompi_ddt_get_extent(rdtype, &lb, &rcvinc); if (OMPI_SUCCESS != err) { - return err; + return err; } rcvinc *= rcount; @@ -203,21 +203,21 @@ mca_coll_basic_alltoall_inter(void *sbuf, int scount, /* Post all receives first */ for (i = 0; i < size; i++, ++rreq) { - err = MCA_PML_CALL(irecv(prcv + (i * rcvinc), rcount, rdtype, i, - MCA_COLL_BASE_TAG_ALLTOALL, comm, rreq)); - if (OMPI_SUCCESS != err) { - return err; - } + err = MCA_PML_CALL(irecv(prcv + (i * rcvinc), rcount, rdtype, i, + MCA_COLL_BASE_TAG_ALLTOALL, comm, rreq)); + if (OMPI_SUCCESS != err) { + return err; + } } /* Now post all sends */ for (i = 0; i < size; i++, ++sreq) { - err = MCA_PML_CALL(isend(psnd + (i * sndinc), scount, sdtype, i, - MCA_COLL_BASE_TAG_ALLTOALL, - MCA_PML_BASE_SEND_STANDARD, comm, sreq)); - if (OMPI_SUCCESS != err) { - return err; - } + err = MCA_PML_CALL(isend(psnd + (i * sndinc), scount, sdtype, i, + MCA_COLL_BASE_TAG_ALLTOALL, + MCA_PML_BASE_SEND_STANDARD, comm, sreq)); + if (OMPI_SUCCESS != err) { + return err; + } } /* Wait for them all. If there's an error, note that we don't diff --git a/ompi/mca/coll/basic/coll_basic_alltoallv.c b/ompi/mca/coll/basic/coll_basic_alltoallv.c index 086b8993a2..1ef9453078 100644 --- a/ompi/mca/coll/basic/coll_basic_alltoallv.c +++ b/ompi/mca/coll/basic/coll_basic_alltoallv.c @@ -35,10 +35,10 @@ */ int mca_coll_basic_alltoallv_intra(void *sbuf, int *scounts, int *sdisps, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *rdisps, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, int *rdisps, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm) { int i; int size; @@ -65,17 +65,17 @@ mca_coll_basic_alltoallv_intra(void *sbuf, int *scounts, int *sdisps, prcv = ((char *) rbuf) + (rdisps[rank] * rcvextent); if (0 != scounts[rank]) { - err = ompi_ddt_sndrcv(psnd, scounts[rank], sdtype, - prcv, rcounts[rank], rdtype); - if (MPI_SUCCESS != err) { - return err; - } + err = ompi_ddt_sndrcv(psnd, scounts[rank], sdtype, + prcv, rcounts[rank], rdtype); + if (MPI_SUCCESS != err) { + return err; + } } /* If only one process, we're done. */ if (1 == size) { - return MPI_SUCCESS; + return MPI_SUCCESS; } /* Initiate all send/recv to/from others. */ @@ -86,40 +86,40 @@ mca_coll_basic_alltoallv_intra(void *sbuf, int *scounts, int *sdisps, /* Post all receives first -- a simple optimization */ for (i = 0; i < size; ++i) { - if (i == rank || 0 == rcounts[i]) { - continue; - } + if (i == rank || 0 == rcounts[i]) { + continue; + } - prcv = ((char *) rbuf) + (rdisps[i] * rcvextent); - err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtype, - i, MCA_COLL_BASE_TAG_ALLTOALLV, comm, - preq++)); - ++nreqs; - if (MPI_SUCCESS != err) { - mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, - nreqs); - return err; - } + prcv = ((char *) rbuf) + (rdisps[i] * rcvextent); + err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtype, + i, MCA_COLL_BASE_TAG_ALLTOALLV, comm, + preq++)); + ++nreqs; + if (MPI_SUCCESS != err) { + mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, + nreqs); + return err; + } } /* Now post all sends */ for (i = 0; i < size; ++i) { - if (i == rank || 0 == scounts[i]) { - continue; - } + if (i == rank || 0 == scounts[i]) { + continue; + } - psnd = ((char *) sbuf) + (sdisps[i] * sndextent); - err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtype, - i, MCA_COLL_BASE_TAG_ALLTOALLV, - MCA_PML_BASE_SEND_STANDARD, comm, - preq++)); - ++nreqs; - if (MPI_SUCCESS != err) { - mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, - nreqs); - return err; - } + psnd = ((char *) sbuf) + (sdisps[i] * sndextent); + err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtype, + i, MCA_COLL_BASE_TAG_ALLTOALLV, + MCA_PML_BASE_SEND_STANDARD, comm, + preq++)); + ++nreqs; + if (MPI_SUCCESS != err) { + mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, + nreqs); + return err; + } } /* Start your engines. This will never return an error. */ @@ -134,7 +134,7 @@ mca_coll_basic_alltoallv_intra(void *sbuf, int *scounts, int *sdisps, * error after we free everything. */ err = ompi_request_wait_all(nreqs, comm->c_coll_basic_data->mccb_reqs, - MPI_STATUSES_IGNORE); + MPI_STATUSES_IGNORE); /* Free the requests. */ @@ -155,10 +155,10 @@ mca_coll_basic_alltoallv_intra(void *sbuf, int *scounts, int *sdisps, */ int mca_coll_basic_alltoallv_inter(void *sbuf, int *scounts, int *sdisps, - struct ompi_datatype_t *sdtype, void *rbuf, - int *rcounts, int *rdisps, - struct ompi_datatype_t *rdtype, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, void *rbuf, + int *rcounts, int *rdisps, + struct ompi_datatype_t *rdtype, + struct ompi_communicator_t *comm) { int i; int rsize; @@ -186,33 +186,33 @@ mca_coll_basic_alltoallv_inter(void *sbuf, int *scounts, int *sdisps, /* Post all receives first */ /* A simple optimization: do not send and recv msgs of length zero */ for (i = 0; i < rsize; ++i) { - prcv = ((char *) rbuf) + (rdisps[i] * rcvextent); - if (rcounts[i] > 0) { - err = MCA_PML_CALL(irecv(prcv, rcounts[i], rdtype, - i, MCA_COLL_BASE_TAG_ALLTOALLV, comm, - &preq[i])); - if (MPI_SUCCESS != err) { - return err; - } - } else { - preq[i] = MPI_REQUEST_NULL; - } + prcv = ((char *) rbuf) + (rdisps[i] * rcvextent); + if (rcounts[i] > 0) { + err = MCA_PML_CALL(irecv(prcv, rcounts[i], rdtype, + i, MCA_COLL_BASE_TAG_ALLTOALLV, comm, + &preq[i])); + if (MPI_SUCCESS != err) { + return err; + } + } else { + preq[i] = MPI_REQUEST_NULL; + } } /* Now post all sends */ for (i = 0; i < rsize; ++i) { - psnd = ((char *) sbuf) + (sdisps[i] * sndextent); - if (scounts[i] > 0) { - err = MCA_PML_CALL(isend(psnd, scounts[i], sdtype, - i, MCA_COLL_BASE_TAG_ALLTOALLV, - MCA_PML_BASE_SEND_STANDARD, comm, - &preq[rsize + i])); - if (MPI_SUCCESS != err) { - return err; - } - } else { - preq[rsize + i] = MPI_REQUEST_NULL; - } + psnd = ((char *) sbuf) + (sdisps[i] * sndextent); + if (scounts[i] > 0) { + err = MCA_PML_CALL(isend(psnd, scounts[i], sdtype, + i, MCA_COLL_BASE_TAG_ALLTOALLV, + MCA_PML_BASE_SEND_STANDARD, comm, + &preq[rsize + i])); + if (MPI_SUCCESS != err) { + return err; + } + } else { + preq[rsize + i] = MPI_REQUEST_NULL; + } } err = ompi_request_wait_all(nreqs, preq, MPI_STATUSES_IGNORE); diff --git a/ompi/mca/coll/basic/coll_basic_alltoallw.c b/ompi/mca/coll/basic/coll_basic_alltoallw.c index 62ccecc0e9..9c0abe332f 100644 --- a/ompi/mca/coll/basic/coll_basic_alltoallw.c +++ b/ompi/mca/coll/basic/coll_basic_alltoallw.c @@ -34,10 +34,10 @@ */ int mca_coll_basic_alltoallw_intra(void *sbuf, int *scounts, int *sdisps, - struct ompi_datatype_t **sdtypes, - void *rbuf, int *rcounts, int *rdisps, - struct ompi_datatype_t **rdtypes, - struct ompi_communicator_t *comm) + struct ompi_datatype_t **sdtypes, + void *rbuf, int *rcounts, int *rdisps, + struct ompi_datatype_t **rdtypes, + struct ompi_communicator_t *comm) { int i; int size; @@ -59,17 +59,17 @@ mca_coll_basic_alltoallw_intra(void *sbuf, int *scounts, int *sdisps, prcv = ((char *) rbuf) + rdisps[rank]; if (0 != scounts[rank]) { - err = ompi_ddt_sndrcv(psnd, scounts[rank], sdtypes[rank], - prcv, rcounts[rank], rdtypes[rank]); - if (MPI_SUCCESS != err) { - return err; - } + err = ompi_ddt_sndrcv(psnd, scounts[rank], sdtypes[rank], + prcv, rcounts[rank], rdtypes[rank]); + if (MPI_SUCCESS != err) { + return err; + } } /* If only one process, we're done. */ if (1 == size) { - return MPI_SUCCESS; + return MPI_SUCCESS; } /* Initiate all send/recv to/from others. */ @@ -80,38 +80,38 @@ mca_coll_basic_alltoallw_intra(void *sbuf, int *scounts, int *sdisps, /* Post all receives first -- a simple optimization */ for (i = 0; i < size; ++i) { - if (i == rank || 0 == rcounts[i]) - continue; + if (i == rank || 0 == rcounts[i]) + continue; - prcv = ((char *) rbuf) + rdisps[i]; - err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtypes[i], - i, MCA_COLL_BASE_TAG_ALLTOALLW, comm, - preq++)); - ++nreqs; - if (MPI_SUCCESS != err) { - mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, - nreqs); - return err; - } + prcv = ((char *) rbuf) + rdisps[i]; + err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtypes[i], + i, MCA_COLL_BASE_TAG_ALLTOALLW, comm, + preq++)); + ++nreqs; + if (MPI_SUCCESS != err) { + mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, + nreqs); + return err; + } } /* Now post all sends */ for (i = 0; i < size; ++i) { - if (i == rank || 0 == scounts[i]) - continue; + if (i == rank || 0 == scounts[i]) + continue; - psnd = ((char *) sbuf) + sdisps[i]; - err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtypes[i], - i, MCA_COLL_BASE_TAG_ALLTOALLW, - MCA_PML_BASE_SEND_STANDARD, comm, - preq++)); - ++nreqs; - if (MPI_SUCCESS != err) { - mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, - nreqs); - return err; - } + psnd = ((char *) sbuf) + sdisps[i]; + err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtypes[i], + i, MCA_COLL_BASE_TAG_ALLTOALLW, + MCA_PML_BASE_SEND_STANDARD, comm, + preq++)); + ++nreqs; + if (MPI_SUCCESS != err) { + mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, + nreqs); + return err; + } } /* Start your engines. This will never return an error. */ @@ -126,7 +126,7 @@ mca_coll_basic_alltoallw_intra(void *sbuf, int *scounts, int *sdisps, * error after we free everything. */ err = ompi_request_wait_all(nreqs, comm->c_coll_basic_data->mccb_reqs, - MPI_STATUSES_IGNORE); + MPI_STATUSES_IGNORE); /* Free the requests. */ @@ -147,10 +147,10 @@ mca_coll_basic_alltoallw_intra(void *sbuf, int *scounts, int *sdisps, */ int mca_coll_basic_alltoallw_inter(void *sbuf, int *scounts, int *sdisps, - struct ompi_datatype_t **sdtypes, - void *rbuf, int *rcounts, int *rdisps, - struct ompi_datatype_t **rdtypes, - struct ompi_communicator_t *comm) + struct ompi_datatype_t **sdtypes, + void *rbuf, int *rcounts, int *rdisps, + struct ompi_datatype_t **rdtypes, + struct ompi_communicator_t *comm) { int i; int size; @@ -171,29 +171,29 @@ mca_coll_basic_alltoallw_inter(void *sbuf, int *scounts, int *sdisps, /* Post all receives first -- a simple optimization */ for (i = 0; i < size; ++i) { - prcv = ((char *) rbuf) + rdisps[i]; - err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtypes[i], - i, MCA_COLL_BASE_TAG_ALLTOALLW, - comm, preq++)); - if (OMPI_SUCCESS != err) { - mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, - nreqs); - return err; - } + prcv = ((char *) rbuf) + rdisps[i]; + err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtypes[i], + i, MCA_COLL_BASE_TAG_ALLTOALLW, + comm, preq++)); + if (OMPI_SUCCESS != err) { + mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, + nreqs); + return err; + } } /* Now post all sends */ for (i = 0; i < size; ++i) { - psnd = ((char *) sbuf) + sdisps[i]; - err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtypes[i], - i, MCA_COLL_BASE_TAG_ALLTOALLW, - MCA_PML_BASE_SEND_STANDARD, comm, - preq++)); - if (OMPI_SUCCESS != err) { - mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, - nreqs); - return err; - } + psnd = ((char *) sbuf) + sdisps[i]; + err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtypes[i], + i, MCA_COLL_BASE_TAG_ALLTOALLW, + MCA_PML_BASE_SEND_STANDARD, comm, + preq++)); + if (OMPI_SUCCESS != err) { + mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, + nreqs); + return err; + } } /* Start your engines. This will never return an error. */ @@ -206,7 +206,7 @@ mca_coll_basic_alltoallw_inter(void *sbuf, int *scounts, int *sdisps, * So free them anyway -- even if there was an error, and return the * error after we free everything. */ err = ompi_request_wait_all(nreqs, comm->c_coll_basic_data->mccb_reqs, - MPI_STATUSES_IGNORE); + MPI_STATUSES_IGNORE); /* Free the requests. */ mca_coll_basic_free_reqs(comm->c_coll_basic_data->mccb_reqs, nreqs); diff --git a/ompi/mca/coll/basic/coll_basic_barrier.c b/ompi/mca/coll/basic/coll_basic_barrier.c index 43ac17f09a..364de4f0dd 100644 --- a/ompi/mca/coll/basic/coll_basic_barrier.c +++ b/ompi/mca/coll/basic/coll_basic_barrier.c @@ -45,45 +45,45 @@ mca_coll_basic_barrier_intra_lin(struct ompi_communicator_t *comm) /* All non-root send & receive zero-length message. */ if (rank > 0) { - err = - MCA_PML_CALL(send - (NULL, 0, MPI_BYTE, 0, MCA_COLL_BASE_TAG_BARRIER, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (MPI_SUCCESS != err) { - return err; - } + err = + MCA_PML_CALL(send + (NULL, 0, MPI_BYTE, 0, MCA_COLL_BASE_TAG_BARRIER, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (MPI_SUCCESS != err) { + return err; + } - err = - MCA_PML_CALL(recv - (NULL, 0, MPI_BYTE, 0, MCA_COLL_BASE_TAG_BARRIER, - comm, MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - return err; - } + err = + MCA_PML_CALL(recv + (NULL, 0, MPI_BYTE, 0, MCA_COLL_BASE_TAG_BARRIER, + comm, MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + return err; + } } /* The root collects and broadcasts the messages. */ else { - for (i = 1; i < size; ++i) { - err = MCA_PML_CALL(recv(NULL, 0, MPI_BYTE, MPI_ANY_SOURCE, - MCA_COLL_BASE_TAG_BARRIER, - comm, MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - return err; - } - } + for (i = 1; i < size; ++i) { + err = MCA_PML_CALL(recv(NULL, 0, MPI_BYTE, MPI_ANY_SOURCE, + MCA_COLL_BASE_TAG_BARRIER, + comm, MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + return err; + } + } - for (i = 1; i < size; ++i) { - err = - MCA_PML_CALL(send - (NULL, 0, MPI_BYTE, i, - MCA_COLL_BASE_TAG_BARRIER, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (MPI_SUCCESS != err) { - return err; - } - } + for (i = 1; i < size; ++i) { + err = + MCA_PML_CALL(send + (NULL, 0, MPI_BYTE, i, + MCA_COLL_BASE_TAG_BARRIER, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (MPI_SUCCESS != err) { + return err; + } + } } /* All done */ @@ -121,47 +121,47 @@ mca_coll_basic_barrier_intra_log(struct ompi_communicator_t *comm) /* Receive from children. */ for (i = dim, mask = 1 << i; i > hibit; --i, mask >>= 1) { - peer = rank | mask; - if (peer < size) { - err = MCA_PML_CALL(recv(NULL, 0, MPI_BYTE, peer, - MCA_COLL_BASE_TAG_BARRIER, - comm, MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - return err; - } - } + peer = rank | mask; + if (peer < size) { + err = MCA_PML_CALL(recv(NULL, 0, MPI_BYTE, peer, + MCA_COLL_BASE_TAG_BARRIER, + comm, MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + return err; + } + } } /* Send to and receive from parent. */ if (rank > 0) { - peer = rank & ~(1 << hibit); - err = - MCA_PML_CALL(send - (NULL, 0, MPI_BYTE, peer, - MCA_COLL_BASE_TAG_BARRIER, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (MPI_SUCCESS != err) { - return err; - } + peer = rank & ~(1 << hibit); + err = + MCA_PML_CALL(send + (NULL, 0, MPI_BYTE, peer, + MCA_COLL_BASE_TAG_BARRIER, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (MPI_SUCCESS != err) { + return err; + } - err = MCA_PML_CALL(recv(NULL, 0, MPI_BYTE, peer, - MCA_COLL_BASE_TAG_BARRIER, - comm, MPI_STATUS_IGNORE)); + err = MCA_PML_CALL(recv(NULL, 0, MPI_BYTE, peer, + MCA_COLL_BASE_TAG_BARRIER, + comm, MPI_STATUS_IGNORE)); } /* Send to children. */ for (i = hibit + 1, mask = 1 << i; i <= dim; ++i, mask <<= 1) { - peer = rank | mask; - if (peer < size) { - err = MCA_PML_CALL(send(NULL, 0, MPI_BYTE, peer, - MCA_COLL_BASE_TAG_BARRIER, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (MPI_SUCCESS != err) { - return err; - } - } + peer = rank | mask; + if (peer < size) { + err = MCA_PML_CALL(send(NULL, 0, MPI_BYTE, peer, + MCA_COLL_BASE_TAG_BARRIER, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (MPI_SUCCESS != err) { + return err; + } + } } /* All done */ @@ -185,5 +185,5 @@ mca_coll_basic_barrier_inter_lin(struct ompi_communicator_t *comm) rank = ompi_comm_rank(comm); return comm->c_coll.coll_allreduce(&rank, &result, 1, MPI_INT, MPI_MAX, - comm); + comm); } diff --git a/ompi/mca/coll/basic/coll_basic_bcast.c b/ompi/mca/coll/basic/coll_basic_bcast.c index 73220bda71..8d367abc23 100644 --- a/ompi/mca/coll/basic/coll_basic_bcast.c +++ b/ompi/mca/coll/basic/coll_basic_bcast.c @@ -37,8 +37,8 @@ */ int mca_coll_basic_bcast_lin_intra(void *buff, int count, - struct ompi_datatype_t *datatype, int root, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *datatype, int root, + struct ompi_communicator_t *comm) { int i; int size; @@ -53,25 +53,25 @@ mca_coll_basic_bcast_lin_intra(void *buff, int count, /* Non-root receive the data. */ if (rank != root) { - return MCA_PML_CALL(recv(buff, count, datatype, root, - MCA_COLL_BASE_TAG_BCAST, comm, - MPI_STATUS_IGNORE)); + return MCA_PML_CALL(recv(buff, count, datatype, root, + MCA_COLL_BASE_TAG_BCAST, comm, + MPI_STATUS_IGNORE)); } /* Root sends data to all others. */ for (i = 0, preq = reqs; i < size; ++i) { - if (i == rank) { - continue; - } + if (i == rank) { + continue; + } - err = MCA_PML_CALL(isend_init(buff, count, datatype, i, - MCA_COLL_BASE_TAG_BCAST, - MCA_PML_BASE_SEND_STANDARD, - comm, preq++)); - if (MPI_SUCCESS != err) { - return err; - } + err = MCA_PML_CALL(isend_init(buff, count, datatype, i, + MCA_COLL_BASE_TAG_BCAST, + MCA_PML_BASE_SEND_STANDARD, + comm, preq++)); + if (MPI_SUCCESS != err) { + return err; + } } --i; @@ -107,8 +107,8 @@ mca_coll_basic_bcast_lin_intra(void *buff, int count, */ int mca_coll_basic_bcast_log_intra(void *buff, int count, - struct ompi_datatype_t *datatype, int root, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *datatype, int root, + struct ompi_communicator_t *comm) { int i; int size; @@ -134,14 +134,14 @@ mca_coll_basic_bcast_log_intra(void *buff, int count, /* Receive data from parent in the tree. */ if (vrank > 0) { - peer = ((vrank & ~(1 << hibit)) + root) % size; + peer = ((vrank & ~(1 << hibit)) + root) % size; - err = MCA_PML_CALL(recv(buff, count, datatype, peer, - MCA_COLL_BASE_TAG_BCAST, - comm, MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - return err; - } + err = MCA_PML_CALL(recv(buff, count, datatype, peer, + MCA_COLL_BASE_TAG_BCAST, + comm, MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + return err; + } } /* Send data to the children. */ @@ -150,42 +150,42 @@ mca_coll_basic_bcast_log_intra(void *buff, int count, preq = reqs; nreqs = 0; for (i = hibit + 1, mask = 1 << i; i <= dim; ++i, mask <<= 1) { - peer = vrank | mask; - if (peer < size) { - peer = (peer + root) % size; - ++nreqs; + peer = vrank | mask; + if (peer < size) { + peer = (peer + root) % size; + ++nreqs; - err = MCA_PML_CALL(isend_init(buff, count, datatype, peer, - MCA_COLL_BASE_TAG_BCAST, - MCA_PML_BASE_SEND_STANDARD, - comm, preq++)); - if (MPI_SUCCESS != err) { - mca_coll_basic_free_reqs(reqs, preq - reqs); - return err; - } - } + err = MCA_PML_CALL(isend_init(buff, count, datatype, peer, + MCA_COLL_BASE_TAG_BCAST, + MCA_PML_BASE_SEND_STANDARD, + comm, preq++)); + if (MPI_SUCCESS != err) { + mca_coll_basic_free_reqs(reqs, preq - reqs); + return err; + } + } } /* Start and wait on all requests. */ if (nreqs > 0) { - /* Start your engines. This will never return an error. */ + /* Start your engines. This will never return an error. */ - MCA_PML_CALL(start(nreqs, reqs)); + MCA_PML_CALL(start(nreqs, reqs)); - /* Wait for them all. If there's an error, note that we don't - * care what the error was -- just that there *was* an error. - * The PML will finish all requests, even if one or more of them - * fail. i.e., by the end of this call, all the requests are - * free-able. So free them anyway -- even if there was an - * error, and return the error after we free everything. */ + /* Wait for them all. If there's an error, note that we don't + * care what the error was -- just that there *was* an error. + * The PML will finish all requests, even if one or more of them + * fail. i.e., by the end of this call, all the requests are + * free-able. So free them anyway -- even if there was an + * error, and return the error after we free everything. */ - err = ompi_request_wait_all(nreqs, reqs, MPI_STATUSES_IGNORE); + err = ompi_request_wait_all(nreqs, reqs, MPI_STATUSES_IGNORE); - /* Free the reqs */ + /* Free the reqs */ - mca_coll_basic_free_reqs(reqs, nreqs); + mca_coll_basic_free_reqs(reqs, nreqs); } /* All done */ @@ -203,8 +203,8 @@ mca_coll_basic_bcast_log_intra(void *buff, int count, */ int mca_coll_basic_bcast_lin_inter(void *buff, int count, - struct ompi_datatype_t *datatype, int root, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *datatype, int root, + struct ompi_communicator_t *comm) { int i; int rsize; @@ -216,25 +216,25 @@ mca_coll_basic_bcast_lin_inter(void *buff, int count, rank = ompi_comm_rank(comm); if (MPI_PROC_NULL == root) { - /* do nothing */ - err = OMPI_SUCCESS; + /* do nothing */ + err = OMPI_SUCCESS; } else if (MPI_ROOT != root) { - /* Non-root receive the data. */ - err = MCA_PML_CALL(recv(buff, count, datatype, root, - MCA_COLL_BASE_TAG_BCAST, comm, - MPI_STATUS_IGNORE)); + /* Non-root receive the data. */ + err = MCA_PML_CALL(recv(buff, count, datatype, root, + MCA_COLL_BASE_TAG_BCAST, comm, + MPI_STATUS_IGNORE)); } else { - /* root section */ - for (i = 0; i < rsize; i++) { - err = MCA_PML_CALL(isend(buff, count, datatype, i, - MCA_COLL_BASE_TAG_BCAST, - MCA_PML_BASE_SEND_STANDARD, - comm, &(reqs[i]))); - if (OMPI_SUCCESS != err) { - return err; - } - } - err = ompi_request_wait_all(rsize, reqs, MPI_STATUSES_IGNORE); + /* root section */ + for (i = 0; i < rsize; i++) { + err = MCA_PML_CALL(isend(buff, count, datatype, i, + MCA_COLL_BASE_TAG_BCAST, + MCA_PML_BASE_SEND_STANDARD, + comm, &(reqs[i]))); + if (OMPI_SUCCESS != err) { + return err; + } + } + err = ompi_request_wait_all(rsize, reqs, MPI_STATUSES_IGNORE); } @@ -252,8 +252,8 @@ mca_coll_basic_bcast_lin_inter(void *buff, int count, */ int mca_coll_basic_bcast_log_inter(void *buff, int count, - struct ompi_datatype_t *datatype, int root, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *datatype, int root, + struct ompi_communicator_t *comm) { return OMPI_ERR_NOT_IMPLEMENTED; } diff --git a/ompi/mca/coll/basic/coll_basic_component.c b/ompi/mca/coll/basic/coll_basic_component.c index 514641539f..6b130986e2 100644 --- a/ompi/mca/coll/basic/coll_basic_component.c +++ b/ompi/mca/coll/basic/coll_basic_component.c @@ -92,7 +92,7 @@ basic_open(void) /* Use a low priority, but allow other components to be lower */ mca_coll_basic_priority_param = - mca_base_param_register_int("coll", "basic", "priority", NULL, 10); + mca_base_param_register_int("coll", "basic", "priority", NULL, 10); return OMPI_SUCCESS; } diff --git a/ompi/mca/coll/basic/coll_basic_exscan.c b/ompi/mca/coll/basic/coll_basic_exscan.c index 3851416b2e..9df72363d9 100644 --- a/ompi/mca/coll/basic/coll_basic_exscan.c +++ b/ompi/mca/coll/basic/coll_basic_exscan.c @@ -38,9 +38,9 @@ */ int mca_coll_basic_exscan_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm) { int size; int rank; @@ -59,18 +59,18 @@ mca_coll_basic_exscan_intra(void *sbuf, void *rbuf, int count, /* If we're rank 0, then we send our sbuf to the next rank */ if (0 == rank) { - return MCA_PML_CALL(send(sbuf, count, dtype, rank + 1, - MCA_COLL_BASE_TAG_EXSCAN, - MCA_PML_BASE_SEND_STANDARD, comm)); + return MCA_PML_CALL(send(sbuf, count, dtype, rank + 1, + MCA_COLL_BASE_TAG_EXSCAN, + MCA_PML_BASE_SEND_STANDARD, comm)); } /* If we're the last rank, then just receive the result from the * prior rank */ else if ((size - 1) == rank) { - return MCA_PML_CALL(recv(rbuf, count, dtype, rank - 1, - MCA_COLL_BASE_TAG_EXSCAN, comm, - MPI_STATUS_IGNORE)); + return MCA_PML_CALL(recv(rbuf, count, dtype, rank - 1, + MCA_COLL_BASE_TAG_EXSCAN, comm, + MPI_STATUS_IGNORE)); } /* Otherwise, get the result from the prior rank, combine it with my @@ -79,9 +79,9 @@ mca_coll_basic_exscan_intra(void *sbuf, void *rbuf, int count, /* Start the receive for the prior rank's answer */ err = MCA_PML_CALL(irecv(rbuf, count, dtype, rank - 1, - MCA_COLL_BASE_TAG_EXSCAN, comm, &req)); + MCA_COLL_BASE_TAG_EXSCAN, comm, &req)); if (MPI_SUCCESS != err) { - goto error; + goto error; } /* Get a temporary buffer to perform the reduction into. Rationale @@ -92,53 +92,53 @@ mca_coll_basic_exscan_intra(void *sbuf, void *rbuf, int count, free_buffer = malloc(true_extent + (count - 1) * extent); if (NULL == free_buffer) { - return OMPI_ERR_OUT_OF_RESOURCE; + return OMPI_ERR_OUT_OF_RESOURCE; } reduce_buffer = free_buffer - lb; if (ompi_op_is_commute(op)) { - /* If we're commutative, we can copy my sbuf into the reduction - * buffer before the receive completes */ + /* If we're commutative, we can copy my sbuf into the reduction + * buffer before the receive completes */ - err = - ompi_ddt_sndrcv(sbuf, count, dtype, reduce_buffer, count, - dtype); - if (MPI_SUCCESS != err) { - goto error; - } + err = + ompi_ddt_sndrcv(sbuf, count, dtype, reduce_buffer, count, + dtype); + if (MPI_SUCCESS != err) { + goto error; + } - /* Now setup the reduction */ + /* Now setup the reduction */ - source = rbuf; + source = rbuf; - /* Finally, wait for the receive to complete (so that we can do - * the reduction). */ + /* Finally, wait for the receive to complete (so that we can do + * the reduction). */ - err = ompi_request_wait(&req, MPI_STATUS_IGNORE); - if (MPI_SUCCESS != err) { - goto error; - } + err = ompi_request_wait(&req, MPI_STATUS_IGNORE); + if (MPI_SUCCESS != err) { + goto error; + } } else { - /* Setup the reduction */ + /* Setup the reduction */ - source = sbuf; + source = sbuf; - /* If we're not commutative, we have to wait for the receive to - * complete and then copy it into the reduce buffer */ + /* If we're not commutative, we have to wait for the receive to + * complete and then copy it into the reduce buffer */ - err = ompi_request_wait(&req, MPI_STATUS_IGNORE); - if (MPI_SUCCESS != err) { - goto error; - } + err = ompi_request_wait(&req, MPI_STATUS_IGNORE); + if (MPI_SUCCESS != err) { + goto error; + } - err = - ompi_ddt_sndrcv(rbuf, count, dtype, reduce_buffer, count, - dtype); - if (MPI_SUCCESS != err) { - goto error; - } + err = + ompi_ddt_sndrcv(rbuf, count, dtype, reduce_buffer, count, + dtype); + if (MPI_SUCCESS != err) { + goto error; + } } /* Now reduce the received answer with my source into the answer @@ -149,16 +149,16 @@ mca_coll_basic_exscan_intra(void *sbuf, void *rbuf, int count, /* Send my result off to the next rank */ err = MCA_PML_CALL(send(reduce_buffer, count, dtype, rank + 1, - MCA_COLL_BASE_TAG_EXSCAN, - MCA_PML_BASE_SEND_STANDARD, comm)); + MCA_COLL_BASE_TAG_EXSCAN, + MCA_PML_BASE_SEND_STANDARD, comm)); /* Error */ error: free(free_buffer); if (MPI_REQUEST_NULL != req) { - ompi_request_cancel(req); - ompi_request_wait(&req, MPI_STATUS_IGNORE); + ompi_request_cancel(req); + ompi_request_wait(&req, MPI_STATUS_IGNORE); } /* All done */ @@ -176,9 +176,9 @@ mca_coll_basic_exscan_intra(void *sbuf, void *rbuf, int count, */ int mca_coll_basic_exscan_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm) { return OMPI_ERR_NOT_IMPLEMENTED; } diff --git a/ompi/mca/coll/basic/coll_basic_gather.c b/ompi/mca/coll/basic/coll_basic_gather.c index c5bfe87ee3..2f047da91e 100644 --- a/ompi/mca/coll/basic/coll_basic_gather.c +++ b/ompi/mca/coll/basic/coll_basic_gather.c @@ -34,10 +34,10 @@ */ int mca_coll_basic_gather_intra(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) + 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; @@ -54,33 +54,33 @@ mca_coll_basic_gather_intra(void *sbuf, int scount, /* Everyone but root sends data and returns. */ if (rank != root) { - return MCA_PML_CALL(send(sbuf, scount, sdtype, root, - MCA_COLL_BASE_TAG_GATHER, - MCA_PML_BASE_SEND_STANDARD, comm)); + 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. */ if (OMPI_SUCCESS != (err = ompi_ddt_get_extent(rdtype, &lb, &extent))) { - return err; + return err; } incr = extent * rcount; for (i = 0, ptmp = (char *) rbuf; i < size; ++i, ptmp += incr) { - /* simple optimization */ + /* simple optimization */ - if (i == rank) { - err = ompi_ddt_sndrcv(sbuf, scount, sdtype, ptmp, - rcount, rdtype); - } 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; - } + if (i == rank) { + err = ompi_ddt_sndrcv(sbuf, scount, sdtype, ptmp, + rcount, rdtype); + } 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 */ @@ -98,10 +98,10 @@ mca_coll_basic_gather_intra(void *sbuf, int scount, */ int mca_coll_basic_gather_inter(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) + 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; @@ -117,29 +117,29 @@ mca_coll_basic_gather_inter(void *sbuf, int scount, if (MPI_PROC_NULL == root) { - /* do nothing */ - err = OMPI_SUCCESS; + /* do nothing */ + err = OMPI_SUCCESS; } else if (MPI_ROOT != root) { - /* Everyone but root sends data and returns. */ - err = MCA_PML_CALL(send(sbuf, scount, sdtype, root, - MCA_COLL_BASE_TAG_GATHER, - MCA_PML_BASE_SEND_STANDARD, comm)); + /* Everyone but root sends data and returns. */ + err = MCA_PML_CALL(send(sbuf, scount, sdtype, root, + MCA_COLL_BASE_TAG_GATHER, + MCA_PML_BASE_SEND_STANDARD, comm)); } else { - /* I am the root, loop receiving the data. */ - err = ompi_ddt_get_extent(rdtype, &lb, &extent); - if (OMPI_SUCCESS != err) { - return OMPI_ERROR; - } + /* I am the root, loop receiving the data. */ + err = ompi_ddt_get_extent(rdtype, &lb, &extent); + if (OMPI_SUCCESS != err) { + return OMPI_ERROR; + } - incr = extent * rcount; - for (i = 0, ptmp = (char *) rbuf; i < size; ++i, ptmp += incr) { - err = MCA_PML_CALL(recv(ptmp, rcount, rdtype, i, - MCA_COLL_BASE_TAG_GATHER, - comm, MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - return err; - } - } + incr = extent * rcount; + for (i = 0, ptmp = (char *) rbuf; i < size; ++i, ptmp += incr) { + 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 */ diff --git a/ompi/mca/coll/basic/coll_basic_gatherv.c b/ompi/mca/coll/basic/coll_basic_gatherv.c index 6aa5c00037..bf22c35eca 100644 --- a/ompi/mca/coll/basic/coll_basic_gatherv.c +++ b/ompi/mca/coll/basic/coll_basic_gatherv.c @@ -34,10 +34,10 @@ */ int mca_coll_basic_gatherv_intra(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *disps, - struct ompi_datatype_t *rdtype, int root, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, int *disps, + struct ompi_datatype_t *rdtype, int root, + struct ompi_communicator_t *comm) { int i; int rank; @@ -51,11 +51,11 @@ mca_coll_basic_gatherv_intra(void *sbuf, int scount, rank = ompi_comm_rank(comm); /* Everyone but root sends data and returns. Note that we will only - get here if scount > 0 or rank == root. */ + * get here if scount > 0 or rank == root. */ if (rank != root) { err = MCA_PML_CALL(send(sbuf, scount, sdtype, root, - MCA_COLL_BASE_TAG_GATHERV, + MCA_COLL_BASE_TAG_GATHERV, MCA_PML_BASE_SEND_STANDARD, comm)); return err; } @@ -71,12 +71,12 @@ mca_coll_basic_gatherv_intra(void *sbuf, int scount, ptmp = ((char *) rbuf) + (extent * disps[i]); if (i == rank) { - if( (0 < scount) && (0 < rcounts[i]) ) /* simple optimization */ + if ((0 < scount) && (0 < rcounts[i])) /* simple optimization */ err = ompi_ddt_sndrcv(sbuf, scount, sdtype, ptmp, rcounts[i], rdtype); } else { err = MCA_PML_CALL(recv(ptmp, rcounts[i], rdtype, i, - MCA_COLL_BASE_TAG_GATHERV, + MCA_COLL_BASE_TAG_GATHERV, comm, MPI_STATUS_IGNORE)); } @@ -100,10 +100,10 @@ mca_coll_basic_gatherv_intra(void *sbuf, int scount, */ int mca_coll_basic_gatherv_inter(void *sbuf, int scount, - struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *disps, - struct ompi_datatype_t *rdtype, int root, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *sdtype, + void *rbuf, int *rcounts, int *disps, + struct ompi_datatype_t *rdtype, int root, + struct ompi_communicator_t *comm) { int i; int rank; @@ -121,31 +121,31 @@ mca_coll_basic_gatherv_inter(void *sbuf, int scount, * scount > 0 or rank == root. */ if (MPI_PROC_NULL == root) { - /* do nothing */ - err = OMPI_SUCCESS; + /* do nothing */ + err = OMPI_SUCCESS; } else if (MPI_ROOT != root) { - /* Everyone but root sends data and returns. */ - err = MCA_PML_CALL(send(sbuf, scount, sdtype, root, - MCA_COLL_BASE_TAG_GATHERV, - MCA_PML_BASE_SEND_STANDARD, comm)); + /* Everyone but root sends data and returns. */ + err = MCA_PML_CALL(send(sbuf, scount, sdtype, root, + MCA_COLL_BASE_TAG_GATHERV, + MCA_PML_BASE_SEND_STANDARD, comm)); } else { - /* I am the root, loop receiving data. */ - err = ompi_ddt_get_extent(rdtype, &lb, &extent); - if (OMPI_SUCCESS != err) { - return OMPI_ERROR; - } + /* I am the root, loop receiving data. */ + err = ompi_ddt_get_extent(rdtype, &lb, &extent); + if (OMPI_SUCCESS != err) { + return OMPI_ERROR; + } - for (i = 0; i < size; ++i) { - ptmp = ((char *) rbuf) + (extent * disps[i]); - err = MCA_PML_CALL(irecv(ptmp, rcounts[i], rdtype, i, - MCA_COLL_BASE_TAG_GATHERV, - comm, &reqs[i])); - if (OMPI_SUCCESS != err) { - return err; - } - } + for (i = 0; i < size; ++i) { + ptmp = ((char *) rbuf) + (extent * disps[i]); + err = MCA_PML_CALL(irecv(ptmp, rcounts[i], rdtype, i, + MCA_COLL_BASE_TAG_GATHERV, + comm, &reqs[i])); + if (OMPI_SUCCESS != err) { + return err; + } + } - err = ompi_request_wait_all(size, reqs, MPI_STATUSES_IGNORE); + err = ompi_request_wait_all(size, reqs, MPI_STATUSES_IGNORE); } /* All done */ diff --git a/ompi/mca/coll/basic/coll_basic_module.c b/ompi/mca/coll/basic/coll_basic_module.c index a06b439119..2ba677d950 100644 --- a/ompi/mca/coll/basic/coll_basic_module.c +++ b/ompi/mca/coll/basic/coll_basic_module.c @@ -129,7 +129,7 @@ static const mca_coll_base_module_1_0_0_t inter_linear = { */ int mca_coll_basic_init_query(bool enable_progress_threads, - bool enable_mpi_threads) + bool enable_mpi_threads) { /* Nothing to do */ @@ -144,25 +144,25 @@ mca_coll_basic_init_query(bool enable_progress_threads, */ const mca_coll_base_module_1_0_0_t * mca_coll_basic_comm_query(struct ompi_communicator_t *comm, int *priority, - struct mca_coll_base_comm_t **data) + struct mca_coll_base_comm_t **data) { if (OMPI_SUCCESS != - mca_base_param_lookup_int(mca_coll_basic_priority_param, - priority)) { - return NULL; + mca_base_param_lookup_int(mca_coll_basic_priority_param, + priority)) { + return NULL; } /* Choose whether to use [intra|inter], and [linear|log]-based * algorithms. */ if (OMPI_COMM_IS_INTER(comm)) { - return &inter_linear; + return &inter_linear; } else { - if (ompi_comm_size(comm) <= mca_coll_base_crossover) { - return &intra_linear; - } else { - return &intra_log; - } + if (ompi_comm_size(comm) <= mca_coll_base_crossover) { + return &intra_linear; + } else { + return &intra_log; + } } /* Never reach here */ @@ -181,15 +181,15 @@ mca_coll_basic_module_init(struct ompi_communicator_t *comm) /* Allocate the data that hangs off the communicator */ if (OMPI_COMM_IS_INTER(comm)) { - size = ompi_comm_remote_size(comm); + size = ompi_comm_remote_size(comm); } else { - size = ompi_comm_size(comm); + size = ompi_comm_size(comm); } data = malloc(sizeof(struct mca_coll_base_comm_t) + - (sizeof(ompi_request_t *) * size * 2)); + (sizeof(ompi_request_t *) * size * 2)); if (NULL == data) { - return NULL; + return NULL; } data->mccb_reqs = (ompi_request_t **) (data + 1); data->mccb_num_reqs = size * 2; @@ -208,7 +208,7 @@ int mca_coll_basic_module_finalize(struct ompi_communicator_t *comm) { if (NULL == comm->c_coll_basic_module) { - return OMPI_SUCCESS; + return OMPI_SUCCESS; } #if OMPI_ENABLE_DEBUG diff --git a/ompi/mca/coll/basic/coll_basic_reduce.c b/ompi/mca/coll/basic/coll_basic_reduce.c index 19d858a0c8..a63576ac86 100644 --- a/ompi/mca/coll/basic/coll_basic_reduce.c +++ b/ompi/mca/coll/basic/coll_basic_reduce.c @@ -35,9 +35,9 @@ */ int mca_coll_basic_reduce_lin_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - int root, struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + int root, struct ompi_communicator_t *comm) { int i; int rank; @@ -56,10 +56,10 @@ mca_coll_basic_reduce_lin_intra(void *sbuf, void *rbuf, int count, /* If not root, send data to the root. */ if (rank != root) { - err = MCA_PML_CALL(send(sbuf, count, dtype, root, - MCA_COLL_BASE_TAG_REDUCE, - MCA_PML_BASE_SEND_STANDARD, comm)); - return err; + err = MCA_PML_CALL(send(sbuf, count, dtype, root, + MCA_COLL_BASE_TAG_REDUCE, + MCA_PML_BASE_SEND_STANDARD, comm)); + return err; } /* Root receives and reduces messages. Allocate buffer to receive @@ -188,58 +188,58 @@ mca_coll_basic_reduce_lin_intra(void *sbuf, void *rbuf, int count, */ if (size > 1) { - ompi_ddt_get_extent(dtype, &lb, &extent); - ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); + ompi_ddt_get_extent(dtype, &lb, &extent); + ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); - free_buffer = malloc(true_extent + (count - 1) * extent); - if (NULL == free_buffer) { - return OMPI_ERR_OUT_OF_RESOURCE; - } - pml_buffer = free_buffer - lb; + free_buffer = malloc(true_extent + (count - 1) * extent); + if (NULL == free_buffer) { + return OMPI_ERR_OUT_OF_RESOURCE; + } + pml_buffer = free_buffer - lb; } /* Initialize the receive buffer. */ if (rank == (size - 1)) { - err = ompi_ddt_sndrcv(sbuf, count, dtype, rbuf, count, dtype); + err = ompi_ddt_sndrcv(sbuf, count, dtype, rbuf, count, dtype); } else { - err = MCA_PML_CALL(recv(rbuf, count, dtype, size - 1, - MCA_COLL_BASE_TAG_REDUCE, comm, - MPI_STATUS_IGNORE)); + err = MCA_PML_CALL(recv(rbuf, count, dtype, size - 1, + MCA_COLL_BASE_TAG_REDUCE, comm, + MPI_STATUS_IGNORE)); } if (MPI_SUCCESS != err) { - if (NULL != free_buffer) { - free(free_buffer); - } - return err; + if (NULL != free_buffer) { + free(free_buffer); + } + return err; } /* Loop receiving and calling reduction function (C or Fortran). */ for (i = size - 2; i >= 0; --i) { - if (rank == i) { - inbuf = sbuf; - } else { - err = MCA_PML_CALL(recv(pml_buffer, count, dtype, i, - MCA_COLL_BASE_TAG_REDUCE, comm, - MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - if (NULL != free_buffer) { - free(free_buffer); - } - return err; - } + if (rank == i) { + inbuf = sbuf; + } else { + err = MCA_PML_CALL(recv(pml_buffer, count, dtype, i, + MCA_COLL_BASE_TAG_REDUCE, comm, + MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + if (NULL != free_buffer) { + free(free_buffer); + } + return err; + } - inbuf = pml_buffer; - } + inbuf = pml_buffer; + } - /* Perform the reduction */ + /* Perform the reduction */ - ompi_op_reduce(op, inbuf, rbuf, count, dtype); + ompi_op_reduce(op, inbuf, rbuf, count, dtype); } if (NULL != free_buffer) { - free(free_buffer); + free(free_buffer); } /* All done */ @@ -257,9 +257,9 @@ mca_coll_basic_reduce_lin_intra(void *sbuf, void *rbuf, int count, */ int mca_coll_basic_reduce_log_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - int root, struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + int root, struct ompi_communicator_t *comm) { int i; int size; @@ -282,8 +282,8 @@ mca_coll_basic_reduce_log_intra(void *sbuf, void *rbuf, int count, * operations. */ if (!ompi_op_is_commute(op)) { - return mca_coll_basic_reduce_lin_intra(sbuf, rbuf, count, dtype, - op, root, comm); + return mca_coll_basic_reduce_lin_intra(sbuf, rbuf, count, dtype, + op, root, comm); } /* Some variables */ @@ -296,32 +296,32 @@ mca_coll_basic_reduce_log_intra(void *sbuf, void *rbuf, int count, * rationale above. */ if (size > 1) { - ompi_ddt_get_extent(dtype, &lb, &extent); - ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); + ompi_ddt_get_extent(dtype, &lb, &extent); + ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); - free_buffer = malloc(true_extent + (count - 1) * extent); - if (NULL == free_buffer) { - return OMPI_ERR_OUT_OF_RESOURCE; - } + free_buffer = malloc(true_extent + (count - 1) * extent); + if (NULL == free_buffer) { + return OMPI_ERR_OUT_OF_RESOURCE; + } - pml_buffer = free_buffer - lb; - /* read the comment about commutative operations (few lines down - * the page) */ - if (ompi_op_is_commute(op)) { - rcv_buffer = pml_buffer; - } + pml_buffer = free_buffer - lb; + /* read the comment about commutative operations (few lines down + * the page) */ + if (ompi_op_is_commute(op)) { + rcv_buffer = pml_buffer; + } - if (rank != root && 0 == (vrank & 1)) { - /* root is the only one required to provide a valid rbuf. - * Assume rbuf is invalid for all other ranks, so fix it up - * here to be valid on all non-leaf ranks */ - free_rbuf = malloc(true_extent + (count - 1) * extent); - if (NULL == free_rbuf) { - free(free_buffer); - return OMPI_ERR_OUT_OF_RESOURCE; - } - rbuf = free_rbuf - lb; - } + if (rank != root && 0 == (vrank & 1)) { + /* root is the only one required to provide a valid rbuf. + * Assume rbuf is invalid for all other ranks, so fix it up + * here to be valid on all non-leaf ranks */ + free_rbuf = malloc(true_extent + (count - 1) * extent); + if (NULL == free_rbuf) { + free(free_buffer); + return OMPI_ERR_OUT_OF_RESOURCE; + } + rbuf = free_rbuf - lb; + } } /* Loop over cube dimensions. High processes send to low ones in the @@ -329,114 +329,114 @@ mca_coll_basic_reduce_log_intra(void *sbuf, void *rbuf, int count, for (i = 0, mask = 1; i < dim; ++i, mask <<= 1) { - /* A high-proc sends to low-proc and stops. */ - if (vrank & mask) { - peer = vrank & ~mask; - if (ompi_op_is_commute(op)) { - peer = (peer + root) % size; - } + /* A high-proc sends to low-proc and stops. */ + if (vrank & mask) { + peer = vrank & ~mask; + if (ompi_op_is_commute(op)) { + peer = (peer + root) % size; + } - err = MCA_PML_CALL(send(snd_buffer, count, - dtype, peer, MCA_COLL_BASE_TAG_REDUCE, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (MPI_SUCCESS != err) { - if (NULL != free_buffer) { - free(free_buffer); - } - if (NULL != free_rbuf) { - free(free_rbuf); - } - return err; - } - snd_buffer = rbuf; - break; - } + err = MCA_PML_CALL(send(snd_buffer, count, + dtype, peer, MCA_COLL_BASE_TAG_REDUCE, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (MPI_SUCCESS != err) { + if (NULL != free_buffer) { + free(free_buffer); + } + if (NULL != free_rbuf) { + free(free_rbuf); + } + return err; + } + snd_buffer = rbuf; + break; + } - /* A low-proc receives, reduces, and moves to a higher - * dimension. */ + /* A low-proc receives, reduces, and moves to a higher + * dimension. */ - else { - peer = vrank | mask; - if (peer >= size) { - continue; - } - if (ompi_op_is_commute(op)) { - peer = (peer + root) % size; - } + else { + peer = vrank | mask; + if (peer >= size) { + continue; + } + if (ompi_op_is_commute(op)) { + peer = (peer + root) % size; + } - /* Most of the time (all except the first one for commutative - * operations) we receive in the user provided buffer - * (rbuf). But the exception is here to allow us to dont have - * to copy from the sbuf to a temporary location. If the - * operation is commutative we dont care in which order we - * apply the operation, so for the first time we can receive - * the data in the pml_buffer and then apply to operation - * between this buffer and the user provided data. */ + /* Most of the time (all except the first one for commutative + * operations) we receive in the user provided buffer + * (rbuf). But the exception is here to allow us to dont have + * to copy from the sbuf to a temporary location. If the + * operation is commutative we dont care in which order we + * apply the operation, so for the first time we can receive + * the data in the pml_buffer and then apply to operation + * between this buffer and the user provided data. */ - err = MCA_PML_CALL(recv(rcv_buffer, count, dtype, peer, - MCA_COLL_BASE_TAG_REDUCE, comm, - MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - if (NULL != free_buffer) { - free(free_buffer); - } - if (NULL != free_rbuf) { - free(free_rbuf); - } - return err; - } - /* Perform the operation. The target is always the user - * provided buffer We do the operation only if we receive it - * not in the user buffer */ - if (snd_buffer != sbuf) { - /* the target buffer is the locally allocated one */ - ompi_op_reduce(op, rcv_buffer, pml_buffer, count, dtype); - } else { - /* If we're commutative, we don't care about the order of - * operations and we can just reduce the operations now. - * If we are not commutative, we have to copy the send - * buffer into a temp buffer (pml_buffer) and then reduce - * what we just received against it. */ - if (!ompi_op_is_commute(op)) { - ompi_ddt_sndrcv(sbuf, count, dtype, pml_buffer, count, - dtype); - ompi_op_reduce(op, rbuf, pml_buffer, count, dtype); - } else { - ompi_op_reduce(op, sbuf, pml_buffer, count, dtype); - } - /* now we have to send the buffer containing the computed data */ - snd_buffer = pml_buffer; - /* starting from now we always receive in the user - * provided buffer */ - rcv_buffer = rbuf; - } - } + err = MCA_PML_CALL(recv(rcv_buffer, count, dtype, peer, + MCA_COLL_BASE_TAG_REDUCE, comm, + MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + if (NULL != free_buffer) { + free(free_buffer); + } + if (NULL != free_rbuf) { + free(free_rbuf); + } + return err; + } + /* Perform the operation. The target is always the user + * provided buffer We do the operation only if we receive it + * not in the user buffer */ + if (snd_buffer != sbuf) { + /* the target buffer is the locally allocated one */ + ompi_op_reduce(op, rcv_buffer, pml_buffer, count, dtype); + } else { + /* If we're commutative, we don't care about the order of + * operations and we can just reduce the operations now. + * If we are not commutative, we have to copy the send + * buffer into a temp buffer (pml_buffer) and then reduce + * what we just received against it. */ + if (!ompi_op_is_commute(op)) { + ompi_ddt_sndrcv(sbuf, count, dtype, pml_buffer, count, + dtype); + ompi_op_reduce(op, rbuf, pml_buffer, count, dtype); + } else { + ompi_op_reduce(op, sbuf, pml_buffer, count, dtype); + } + /* now we have to send the buffer containing the computed data */ + snd_buffer = pml_buffer; + /* starting from now we always receive in the user + * provided buffer */ + rcv_buffer = rbuf; + } + } } /* Get the result to the root if needed. */ err = MPI_SUCCESS; if (0 == vrank) { - if (root == rank) { - ompi_ddt_sndrcv(snd_buffer, count, dtype, rbuf, count, dtype); - } else { - err = MCA_PML_CALL(send(snd_buffer, count, - dtype, root, MCA_COLL_BASE_TAG_REDUCE, - MCA_PML_BASE_SEND_STANDARD, comm)); - } + if (root == rank) { + ompi_ddt_sndrcv(snd_buffer, count, dtype, rbuf, count, dtype); + } else { + err = MCA_PML_CALL(send(snd_buffer, count, + dtype, root, MCA_COLL_BASE_TAG_REDUCE, + MCA_PML_BASE_SEND_STANDARD, comm)); + } } else if (rank == root) { - err = MCA_PML_CALL(recv(rcv_buffer, count, dtype, 0, - MCA_COLL_BASE_TAG_REDUCE, - comm, MPI_STATUS_IGNORE)); - if (rcv_buffer != rbuf) { - ompi_op_reduce(op, rcv_buffer, rbuf, count, dtype); - } + err = MCA_PML_CALL(recv(rcv_buffer, count, dtype, 0, + MCA_COLL_BASE_TAG_REDUCE, + comm, MPI_STATUS_IGNORE)); + if (rcv_buffer != rbuf) { + ompi_op_reduce(op, rcv_buffer, rbuf, count, dtype); + } } if (NULL != free_buffer) { - free(free_buffer); + free(free_buffer); } if (NULL != free_rbuf) { - free(free_rbuf); + free(free_rbuf); } /* All done */ @@ -454,9 +454,9 @@ mca_coll_basic_reduce_log_intra(void *sbuf, void *rbuf, int count, */ int mca_coll_basic_reduce_lin_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - int root, struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + int root, struct ompi_communicator_t *comm) { int i; int rank; @@ -471,55 +471,55 @@ mca_coll_basic_reduce_lin_inter(void *sbuf, void *rbuf, int count, size = ompi_comm_remote_size(comm); if (MPI_PROC_NULL == root) { - /* do nothing */ - err = OMPI_SUCCESS; + /* do nothing */ + err = OMPI_SUCCESS; } else if (MPI_ROOT != root) { - /* If not root, send data to the root. */ - err = MCA_PML_CALL(send(sbuf, count, dtype, root, - MCA_COLL_BASE_TAG_REDUCE, - MCA_PML_BASE_SEND_STANDARD, comm)); + /* If not root, send data to the root. */ + err = MCA_PML_CALL(send(sbuf, count, dtype, root, + MCA_COLL_BASE_TAG_REDUCE, + MCA_PML_BASE_SEND_STANDARD, comm)); } else { - /* Root receives and reduces messages */ - ompi_ddt_get_extent(dtype, &lb, &extent); - ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); + /* Root receives and reduces messages */ + ompi_ddt_get_extent(dtype, &lb, &extent); + ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); - free_buffer = malloc(true_extent + (count - 1) * extent); - if (NULL == free_buffer) { - return OMPI_ERR_OUT_OF_RESOURCE; - } - pml_buffer = free_buffer - lb; + free_buffer = malloc(true_extent + (count - 1) * extent); + if (NULL == free_buffer) { + return OMPI_ERR_OUT_OF_RESOURCE; + } + pml_buffer = free_buffer - lb; - /* Initialize the receive buffer. */ - err = MCA_PML_CALL(recv(rbuf, count, dtype, 0, - MCA_COLL_BASE_TAG_REDUCE, comm, - MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - if (NULL != free_buffer) { - free(free_buffer); - } - return err; - } + /* Initialize the receive buffer. */ + err = MCA_PML_CALL(recv(rbuf, count, dtype, 0, + MCA_COLL_BASE_TAG_REDUCE, comm, + MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + if (NULL != free_buffer) { + free(free_buffer); + } + return err; + } - /* Loop receiving and calling reduction function (C or Fortran). */ - for (i = 1; i < size; i++) { - err = MCA_PML_CALL(recv(pml_buffer, count, dtype, i, - MCA_COLL_BASE_TAG_REDUCE, comm, - MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - if (NULL != free_buffer) { - free(free_buffer); - } - return err; - } + /* Loop receiving and calling reduction function (C or Fortran). */ + for (i = 1; i < size; i++) { + err = MCA_PML_CALL(recv(pml_buffer, count, dtype, i, + MCA_COLL_BASE_TAG_REDUCE, comm, + MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + if (NULL != free_buffer) { + free(free_buffer); + } + return err; + } - /* Perform the reduction */ - ompi_op_reduce(op, pml_buffer, rbuf, count, dtype); - } + /* Perform the reduction */ + ompi_op_reduce(op, pml_buffer, rbuf, count, dtype); + } - if (NULL != free_buffer) { - free(free_buffer); - } + if (NULL != free_buffer) { + free(free_buffer); + } } /* All done */ @@ -536,9 +536,9 @@ mca_coll_basic_reduce_lin_inter(void *sbuf, void *rbuf, int count, */ int mca_coll_basic_reduce_log_inter(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - int root, struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + int root, struct ompi_communicator_t *comm) { return OMPI_ERR_NOT_IMPLEMENTED; } diff --git a/ompi/mca/coll/basic/coll_basic_reduce_scatter.c b/ompi/mca/coll/basic/coll_basic_reduce_scatter.c index bc181fbafe..108d68b1e5 100644 --- a/ompi/mca/coll/basic/coll_basic_reduce_scatter.c +++ b/ompi/mca/coll/basic/coll_basic_reduce_scatter.c @@ -37,9 +37,9 @@ */ int mca_coll_basic_reduce_scatter_intra(void *sbuf, void *rbuf, int *rcounts, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm) { int i; int err; @@ -59,58 +59,58 @@ mca_coll_basic_reduce_scatter_intra(void *sbuf, void *rbuf, int *rcounts, /* Initialize reduce & scatterv info at the root (rank 0). */ for (i = 0, count = 0; i < size; ++i) { - if (rcounts[i] < 0) { - return EINVAL; - } - count += rcounts[i]; + if (rcounts[i] < 0) { + return EINVAL; + } + count += rcounts[i]; } if (0 == rank) { - disps = malloc((unsigned) size * sizeof(int)); - if (NULL == disps) { - return OMPI_ERR_OUT_OF_RESOURCE; - } + disps = malloc((unsigned) size * sizeof(int)); + if (NULL == disps) { + return OMPI_ERR_OUT_OF_RESOURCE; + } - /* There is lengthy rationale about how this malloc works in - * coll_basic_reduce.c */ + /* There is lengthy rationale about how this malloc works in + * coll_basic_reduce.c */ - ompi_ddt_get_extent(dtype, &lb, &extent); - ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); + ompi_ddt_get_extent(dtype, &lb, &extent); + ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); - free_buffer = malloc(true_extent + (count - 1) * extent); - if (NULL == free_buffer) { - free(disps); - return OMPI_ERR_OUT_OF_RESOURCE; - } - pml_buffer = free_buffer - lb; + free_buffer = malloc(true_extent + (count - 1) * extent); + if (NULL == free_buffer) { + free(disps); + return OMPI_ERR_OUT_OF_RESOURCE; + } + pml_buffer = free_buffer - lb; - disps[0] = 0; - for (i = 0; i < (size - 1); ++i) { - disps[i + 1] = disps[i] + rcounts[i]; - } + disps[0] = 0; + for (i = 0; i < (size - 1); ++i) { + disps[i + 1] = disps[i] + rcounts[i]; + } } /* reduction */ err = - comm->c_coll.coll_reduce(sbuf, pml_buffer, count, dtype, op, 0, - comm); + comm->c_coll.coll_reduce(sbuf, pml_buffer, count, dtype, op, 0, + comm); /* scatter */ if (MPI_SUCCESS == err) { - err = comm->c_coll.coll_scatterv(pml_buffer, rcounts, disps, dtype, - rbuf, rcounts[rank], dtype, 0, - comm); + err = comm->c_coll.coll_scatterv(pml_buffer, rcounts, disps, dtype, + rbuf, rcounts[rank], dtype, 0, + comm); } /* All done */ if (NULL != disps) { - free(disps); + free(disps); } if (NULL != free_buffer) { - free(free_buffer); + free(free_buffer); } return err; @@ -126,9 +126,9 @@ mca_coll_basic_reduce_scatter_intra(void *sbuf, void *rbuf, int *rcounts, */ int mca_coll_basic_reduce_scatter_inter(void *sbuf, void *rbuf, int *rcounts, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm) { int err, i; int rank; @@ -148,7 +148,7 @@ mca_coll_basic_reduce_scatter_inter(void *sbuf, void *rbuf, int *rcounts, * that locally. */ for (totalcounts = 0, i = 0; i < rsize; i++) { - totalcounts += rcounts[i]; + totalcounts += rcounts[i]; } /* determine result of the remote group, you cannot @@ -161,61 +161,61 @@ mca_coll_basic_reduce_scatter_inter(void *sbuf, void *rbuf, int *rcounts, * simultaniously. */ /*****************************************************************/ if (rank == root) { - err = ompi_ddt_get_extent(dtype, &lb, &extent); - if (OMPI_SUCCESS != err) { - return OMPI_ERROR; - } + err = ompi_ddt_get_extent(dtype, &lb, &extent); + if (OMPI_SUCCESS != err) { + return OMPI_ERROR; + } - tmpbuf = (char *) malloc(totalcounts * extent); - tmpbuf2 = (char *) malloc(totalcounts * extent); - if (NULL == tmpbuf || NULL == tmpbuf2) { - return OMPI_ERR_OUT_OF_RESOURCE; - } + tmpbuf = (char *) malloc(totalcounts * extent); + tmpbuf2 = (char *) malloc(totalcounts * extent); + if (NULL == tmpbuf || NULL == tmpbuf2) { + return OMPI_ERR_OUT_OF_RESOURCE; + } - /* Do a send-recv between the two root procs. to avoid deadlock */ - err = MCA_PML_CALL(isend(sbuf, totalcounts, dtype, 0, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, - MCA_PML_BASE_SEND_STANDARD, comm, &req)); - if (OMPI_SUCCESS != err) { - goto exit; - } + /* Do a send-recv between the two root procs. to avoid deadlock */ + err = MCA_PML_CALL(isend(sbuf, totalcounts, dtype, 0, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, + MCA_PML_BASE_SEND_STANDARD, comm, &req)); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = MCA_PML_CALL(recv(tmpbuf2, totalcounts, dtype, 0, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, comm, - MPI_STATUS_IGNORE)); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = MCA_PML_CALL(recv(tmpbuf2, totalcounts, dtype, 0, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, comm, + MPI_STATUS_IGNORE)); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = ompi_request_wait_all(1, &req, MPI_STATUS_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = ompi_request_wait_all(1, &req, MPI_STATUS_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } - /* Loop receiving and calling reduction function (C or Fortran) - * The result of this reduction operations is then in - * tmpbuf2. - */ - for (i = 1; i < rsize; i++) { - err = MCA_PML_CALL(recv(tmpbuf, totalcounts, dtype, i, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, comm, - MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - goto exit; - } + /* Loop receiving and calling reduction function (C or Fortran) + * The result of this reduction operations is then in + * tmpbuf2. + */ + for (i = 1; i < rsize; i++) { + err = MCA_PML_CALL(recv(tmpbuf, totalcounts, dtype, i, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, comm, + MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + goto exit; + } - /* Perform the reduction */ - ompi_op_reduce(op, tmpbuf, tmpbuf2, totalcounts, dtype); - } + /* Perform the reduction */ + ompi_op_reduce(op, tmpbuf, tmpbuf2, totalcounts, dtype); + } } else { - /* If not root, send data to the root. */ - err = MCA_PML_CALL(send(sbuf, totalcounts, dtype, root, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (OMPI_SUCCESS != err) { - goto exit; - } + /* If not root, send data to the root. */ + err = MCA_PML_CALL(send(sbuf, totalcounts, dtype, root, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (OMPI_SUCCESS != err) { + goto exit; + } } @@ -226,73 +226,73 @@ mca_coll_basic_reduce_scatter_inter(void *sbuf, void *rbuf, int *rcounts, */ /***************************************************************************/ if (rank == root) { - /* sendrecv between the two roots */ - err = MCA_PML_CALL(irecv(tmpbuf, totalcounts, dtype, 0, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, - comm, &req)); - if (OMPI_SUCCESS != err) { - goto exit; - } + /* sendrecv between the two roots */ + err = MCA_PML_CALL(irecv(tmpbuf, totalcounts, dtype, 0, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, + comm, &req)); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = MCA_PML_CALL(send(tmpbuf2, totalcounts, dtype, 0, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, - MCA_PML_BASE_SEND_STANDARD, comm)); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = MCA_PML_CALL(send(tmpbuf2, totalcounts, dtype, 0, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, + MCA_PML_BASE_SEND_STANDARD, comm)); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = ompi_request_wait_all(1, &req, MPI_STATUS_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = ompi_request_wait_all(1, &req, MPI_STATUS_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } - /* distribute the data to other processes in remote group. - * Note that we start from 1 (not from zero), since zero - * has already the correct data AND we avoid a potential - * deadlock here. - */ - err = MCA_PML_CALL(irecv(rbuf, rcounts[rank], dtype, root, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, - comm, &req)); + /* distribute the data to other processes in remote group. + * Note that we start from 1 (not from zero), since zero + * has already the correct data AND we avoid a potential + * deadlock here. + */ + err = MCA_PML_CALL(irecv(rbuf, rcounts[rank], dtype, root, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, + comm, &req)); - tcount = 0; - for (i = 0; i < rsize; i++) { - tbuf = (char *) tmpbuf + tcount * extent; - err = MCA_PML_CALL(isend(tbuf, rcounts[i], dtype, i, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, - MCA_PML_BASE_SEND_STANDARD, comm, - reqs++)); - if (OMPI_SUCCESS != err) { - goto exit; - } - tcount += rcounts[i]; - } + tcount = 0; + for (i = 0; i < rsize; i++) { + tbuf = (char *) tmpbuf + tcount * extent; + err = MCA_PML_CALL(isend(tbuf, rcounts[i], dtype, i, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, + MCA_PML_BASE_SEND_STANDARD, comm, + reqs++)); + if (OMPI_SUCCESS != err) { + goto exit; + } + tcount += rcounts[i]; + } - err = - ompi_request_wait_all(rsize, - comm->c_coll_basic_data->mccb_reqs, - MPI_STATUSES_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = + ompi_request_wait_all(rsize, + comm->c_coll_basic_data->mccb_reqs, + MPI_STATUSES_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } - err = ompi_request_wait_all(1, &req, MPI_STATUS_IGNORE); - if (OMPI_SUCCESS != err) { - goto exit; - } + err = ompi_request_wait_all(1, &req, MPI_STATUS_IGNORE); + if (OMPI_SUCCESS != err) { + goto exit; + } } else { - err = MCA_PML_CALL(recv(rbuf, rcounts[rank], dtype, root, - MCA_COLL_BASE_TAG_REDUCE_SCATTER, - comm, MPI_STATUS_IGNORE)); + err = MCA_PML_CALL(recv(rbuf, rcounts[rank], dtype, root, + MCA_COLL_BASE_TAG_REDUCE_SCATTER, + comm, MPI_STATUS_IGNORE)); } exit: if (NULL != tmpbuf) { - free(tmpbuf); + free(tmpbuf); } if (NULL != tmpbuf2) { - free(tmpbuf2); + free(tmpbuf2); } return err; diff --git a/ompi/mca/coll/basic/coll_basic_scan.c b/ompi/mca/coll/basic/coll_basic_scan.c index 786a5a47fa..a28c7098d9 100644 --- a/ompi/mca/coll/basic/coll_basic_scan.c +++ b/ompi/mca/coll/basic/coll_basic_scan.c @@ -36,9 +36,9 @@ */ int mca_coll_basic_scan_intra(void *sbuf, void *rbuf, int count, - struct ompi_datatype_t *dtype, - struct ompi_op_t *op, - struct ompi_communicator_t *comm) + struct ompi_datatype_t *dtype, + struct ompi_op_t *op, + struct ompi_communicator_t *comm) { int size; int rank; @@ -55,69 +55,69 @@ mca_coll_basic_scan_intra(void *sbuf, void *rbuf, int count, /* If I'm rank 0, just copy into the receive buffer */ if (0 == rank) { - err = ompi_ddt_sndrcv(sbuf, count, dtype, rbuf, count, dtype); - if (MPI_SUCCESS != err) { - return err; - } + err = ompi_ddt_sndrcv(sbuf, count, dtype, rbuf, count, dtype); + if (MPI_SUCCESS != err) { + return err; + } } /* Otherwise receive previous buffer and reduce. */ else { - /* Allocate a temporary buffer. Rationale for this size is - * listed in coll_basic_reduce.c. Use this temporary buffer to - * receive into, later. */ + /* Allocate a temporary buffer. Rationale for this size is + * listed in coll_basic_reduce.c. Use this temporary buffer to + * receive into, later. */ - if (size > 1) { - ompi_ddt_get_extent(dtype, &lb, &extent); - ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); + if (size > 1) { + ompi_ddt_get_extent(dtype, &lb, &extent); + ompi_ddt_get_true_extent(dtype, &true_lb, &true_extent); - free_buffer = malloc(true_extent + (count - 1) * extent); - if (NULL == free_buffer) { - return OMPI_ERR_OUT_OF_RESOURCE; - } - pml_buffer = free_buffer - lb; - } + free_buffer = malloc(true_extent + (count - 1) * extent); + if (NULL == free_buffer) { + return OMPI_ERR_OUT_OF_RESOURCE; + } + pml_buffer = free_buffer - lb; + } - /* Copy the send buffer into the receive buffer. */ + /* Copy the send buffer into the receive buffer. */ - err = ompi_ddt_sndrcv(sbuf, count, dtype, rbuf, count, dtype); - if (MPI_SUCCESS != err) { - if (NULL != free_buffer) { - free(free_buffer); - } - return err; - } + err = ompi_ddt_sndrcv(sbuf, count, dtype, rbuf, count, dtype); + if (MPI_SUCCESS != err) { + if (NULL != free_buffer) { + free(free_buffer); + } + return err; + } - /* Receive the prior answer */ + /* Receive the prior answer */ - err = MCA_PML_CALL(recv(pml_buffer, count, dtype, - rank - 1, MCA_COLL_BASE_TAG_SCAN, comm, - MPI_STATUS_IGNORE)); - if (MPI_SUCCESS != err) { - if (NULL != free_buffer) { - free(free_buffer); - } - return err; - } + err = MCA_PML_CALL(recv(pml_buffer, count, dtype, + rank - 1, MCA_COLL_BASE_TAG_SCAN, comm, + MPI_STATUS_IGNORE)); + if (MPI_SUCCESS != err) { + if (NULL != free_buffer) { + free(free_buffer); + } + return err; + } - /* Perform the operation */ + /* Perform the operation */ - ompi_op_reduce(op, pml_buffer, rbuf, count, dtype); + ompi_op_reduce(op, pml_buffer, rbuf, count, dtype); - /* All done */ + /* All done */ - if (NULL != free_buffer) { - free(free_buffer); - } + if (NULL != free_buffer) { + free(free_buffer); + } } /* Send result to next process. */ if (rank < (size - 1)) { - return MCA_PML_CALL(send(rbuf, count, dtype, rank + 1, - MCA_COLL_BASE_TAG_SCAN, - MCA_PML_BASE_SEND_STANDARD, comm)); + return MCA_PML_CALL(send(rbuf, count, dtype, rank + 1, + MCA_COLL_BASE_TAG_SCAN, + MCA_PML_BASE_SEND_STANDARD, comm)); } /* All done */ diff --git a/ompi/mca/coll/basic/coll_basic_scatter.c b/ompi/mca/coll/basic/coll_basic_scatter.c index 4e22c04792..5cb60605dc 100644 --- a/ompi/mca/coll/basic/coll_basic_scatter.c +++ b/ompi/mca/coll/basic/coll_basic_scatter.c @@ -35,10 +35,10 @@ */ int mca_coll_basic_scatter_intra(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) + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + int root, struct ompi_communicator_t *comm) { int i; int rank; @@ -56,36 +56,36 @@ mca_coll_basic_scatter_intra(void *sbuf, int scount, /* If not root, receive data. */ if (rank != root) { - err = MCA_PML_CALL(recv(rbuf, rcount, rdtype, root, - MCA_COLL_BASE_TAG_SCATTER, - comm, MPI_STATUS_IGNORE)); - return err; + err = MCA_PML_CALL(recv(rbuf, rcount, rdtype, root, + MCA_COLL_BASE_TAG_SCATTER, + comm, MPI_STATUS_IGNORE)); + return err; } /* I am the root, loop sending data. */ err = ompi_ddt_get_extent(rdtype, &lb, &incr); if (OMPI_SUCCESS != err) { - return OMPI_ERROR; + return OMPI_ERROR; } incr *= scount; for (i = 0, ptmp = (char *) sbuf; i < size; ++i, ptmp += incr) { - /* simple optimization */ + /* simple optimization */ - if (i == rank) { - err = - ompi_ddt_sndrcv(ptmp, scount, sdtype, rbuf, rcount, - rdtype); - } else { - err = MCA_PML_CALL(send(ptmp, scount, sdtype, i, - MCA_COLL_BASE_TAG_SCATTER, - MCA_PML_BASE_SEND_STANDARD, comm)); - } - if (MPI_SUCCESS != err) { - return err; - } + if (i == rank) { + err = + ompi_ddt_sndrcv(ptmp, scount, sdtype, rbuf, rcount, + rdtype); + } else { + err = MCA_PML_CALL(send(ptmp, scount, sdtype, i, + MCA_COLL_BASE_TAG_SCATTER, + MCA_PML_BASE_SEND_STANDARD, comm)); + } + if (MPI_SUCCESS != err) { + return err; + } } /* All done */ @@ -103,10 +103,10 @@ mca_coll_basic_scatter_intra(void *sbuf, int scount, */ int mca_coll_basic_scatter_inter(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) + struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, + int root, struct ompi_communicator_t *comm) { int i; int rank; @@ -123,34 +123,34 @@ mca_coll_basic_scatter_inter(void *sbuf, int scount, size = ompi_comm_remote_size(comm); if (MPI_PROC_NULL == root) { - /* do nothing */ - err = OMPI_SUCCESS; + /* do nothing */ + err = OMPI_SUCCESS; } else if (MPI_ROOT != root) { - /* If not root, receive data. */ - err = MCA_PML_CALL(recv(rbuf, rcount, rdtype, root, - MCA_COLL_BASE_TAG_SCATTER, - comm, MPI_STATUS_IGNORE)); + /* If not root, receive data. */ + err = MCA_PML_CALL(recv(rbuf, rcount, rdtype, root, + MCA_COLL_BASE_TAG_SCATTER, + comm, MPI_STATUS_IGNORE)); } else { - /* I am the root, loop sending data. */ - err = ompi_ddt_get_extent(rdtype, &lb, &incr); - if (OMPI_SUCCESS != err) { - return OMPI_ERROR; - } + /* I am the root, loop sending data. */ + err = ompi_ddt_get_extent(rdtype, &lb, &incr); + if (OMPI_SUCCESS != err) { + return OMPI_ERROR; + } - incr *= scount; - for (i = 0, ptmp = (char *) sbuf; i < size; ++i, ptmp += incr) { - err = MCA_PML_CALL(isend(ptmp, scount, sdtype, i, - MCA_COLL_BASE_TAG_SCATTER, - MCA_PML_BASE_SEND_STANDARD, comm, - reqs++)); - if (OMPI_SUCCESS != err) { - return err; - } - } + incr *= scount; + for (i = 0, ptmp = (char *) sbuf; i < size; ++i, ptmp += incr) { + err = MCA_PML_CALL(isend(ptmp, scount, sdtype, i, + MCA_COLL_BASE_TAG_SCATTER, + MCA_PML_BASE_SEND_STANDARD, comm, + reqs++)); + if (OMPI_SUCCESS != err) { + return err; + } + } - err = - ompi_request_wait_all(size, comm->c_coll_basic_data->mccb_reqs, - MPI_STATUSES_IGNORE); + err = + ompi_request_wait_all(size, comm->c_coll_basic_data->mccb_reqs, + MPI_STATUSES_IGNORE); } return err; diff --git a/ompi/mca/coll/basic/coll_basic_scatterv.c b/ompi/mca/coll/basic/coll_basic_scatterv.c index adbdc96c49..7f09bb4606 100644 --- a/ompi/mca/coll/basic/coll_basic_scatterv.c +++ b/ompi/mca/coll/basic/coll_basic_scatterv.c @@ -35,10 +35,10 @@ */ int mca_coll_basic_scatterv_intra(void *sbuf, int *scounts, - int *disps, struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, int root, - struct ompi_communicator_t *comm) + int *disps, struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, int root, + struct ompi_communicator_t *comm) { int i; int rank; @@ -57,39 +57,39 @@ mca_coll_basic_scatterv_intra(void *sbuf, int *scounts, * rcount > 0 or rank == root. */ if (rank != root) { - err = MCA_PML_CALL(recv(rbuf, rcount, rdtype, - root, MCA_COLL_BASE_TAG_SCATTERV, - comm, MPI_STATUS_IGNORE)); - return err; + err = MCA_PML_CALL(recv(rbuf, rcount, rdtype, + root, MCA_COLL_BASE_TAG_SCATTERV, + comm, MPI_STATUS_IGNORE)); + return err; } /* I am the root, loop sending data. */ err = ompi_ddt_get_extent(rdtype, &lb, &extent); if (OMPI_SUCCESS != err) { - return OMPI_ERROR; + return OMPI_ERROR; } for (i = 0; i < size; ++i) { - ptmp = ((char *) sbuf) + (extent * disps[i]); + ptmp = ((char *) sbuf) + (extent * disps[i]); - /* simple optimization */ + /* simple optimization */ - if (i == rank) { - if (0 == scounts[i]) { /* simple optimization or a local operation */ - continue; - } - err = - ompi_ddt_sndrcv(ptmp, scounts[i], sdtype, rbuf, rcount, - rdtype); - } else { - err = MCA_PML_CALL(send(ptmp, scounts[i], sdtype, i, - MCA_COLL_BASE_TAG_SCATTERV, - MCA_PML_BASE_SEND_STANDARD, comm)); - } - if (MPI_SUCCESS != err) { - return err; - } + if (i == rank) { + if (0 == scounts[i]) { /* simple optimization or a local operation */ + continue; + } + err = + ompi_ddt_sndrcv(ptmp, scounts[i], sdtype, rbuf, rcount, + rdtype); + } else { + err = MCA_PML_CALL(send(ptmp, scounts[i], sdtype, i, + MCA_COLL_BASE_TAG_SCATTERV, + MCA_PML_BASE_SEND_STANDARD, comm)); + } + if (MPI_SUCCESS != err) { + return err; + } } /* All done */ @@ -107,10 +107,10 @@ mca_coll_basic_scatterv_intra(void *sbuf, int *scounts, */ int mca_coll_basic_scatterv_inter(void *sbuf, int *scounts, - int *disps, struct ompi_datatype_t *sdtype, - void *rbuf, int rcount, - struct ompi_datatype_t *rdtype, int root, - struct ompi_communicator_t *comm) + int *disps, struct ompi_datatype_t *sdtype, + void *rbuf, int rcount, + struct ompi_datatype_t *rdtype, int root, + struct ompi_communicator_t *comm) { int i; int rank; @@ -130,32 +130,32 @@ mca_coll_basic_scatterv_inter(void *sbuf, int *scounts, * rcount > 0 or rank == root. */ if (MPI_PROC_NULL == root) { - /* do nothing */ - err = OMPI_SUCCESS; + /* do nothing */ + err = OMPI_SUCCESS; } else if (MPI_ROOT != root) { - /* If not root, receive data. */ - err = MCA_PML_CALL(recv(rbuf, rcount, rdtype, - root, MCA_COLL_BASE_TAG_SCATTERV, - comm, MPI_STATUS_IGNORE)); + /* If not root, receive data. */ + err = MCA_PML_CALL(recv(rbuf, rcount, rdtype, + root, MCA_COLL_BASE_TAG_SCATTERV, + comm, MPI_STATUS_IGNORE)); } else { - /* I am the root, loop sending data. */ - err = ompi_ddt_get_extent(rdtype, &lb, &extent); - if (OMPI_SUCCESS != err) { - return OMPI_ERROR; - } + /* I am the root, loop sending data. */ + err = ompi_ddt_get_extent(rdtype, &lb, &extent); + if (OMPI_SUCCESS != err) { + return OMPI_ERROR; + } - for (i = 0; i < size; ++i) { - ptmp = ((char *) sbuf) + (extent * disps[i]); - err = MCA_PML_CALL(isend(ptmp, scounts[i], sdtype, i, - MCA_COLL_BASE_TAG_SCATTERV, - MCA_PML_BASE_SEND_STANDARD, comm, - &(reqs[i]))); - if (OMPI_SUCCESS != err) { - return err; - } - } + for (i = 0; i < size; ++i) { + ptmp = ((char *) sbuf) + (extent * disps[i]); + err = MCA_PML_CALL(isend(ptmp, scounts[i], sdtype, i, + MCA_COLL_BASE_TAG_SCATTERV, + MCA_PML_BASE_SEND_STANDARD, comm, + &(reqs[i]))); + if (OMPI_SUCCESS != err) { + return err; + } + } - err = ompi_request_wait_all(size, reqs, MPI_STATUSES_IGNORE); + err = ompi_request_wait_all(size, reqs, MPI_STATUSES_IGNORE); } /* All done */