ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Make a pass through all top-level MPI functions

Просмотр исходного кода 
- Mark those who are still not yet implemented:
  - return an error
  - have a grep-able string indicating that they are not yet
    implemented
- ensure every function checks for init/finalize
- add more error checking to a bunch of functions
- unify the error checking -- it reflected about 3 different
  [previous] error checking styles and MPI exception invocation styles

This commit was SVN r1817.
Этот коммит содержится в:
Jeff Squyres 2004-07-30 02:58:53 +00:00
родитель 5f3c72b19f
Коммит eeee18fce8
278 изменённых файлов: 2867 добавлений и 1070 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

16
src/mpi/c/abort.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Abort = PMPI_Abort
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_Abort(MPI_Comm comm, int errorcode) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_Abort";
int MPI_Abort(MPI_Comm comm, int errorcode)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

19
src/mpi/c/accumulate.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Accumulate = PMPI_Accumulate
@ -15,9 +17,18 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_Accumulate(void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
int target_rank, MPI_Aint target_disp, int target_count,
MPI_Datatype target_datatype, MPI_Op op, MPI_Win win) {
static const char FUNC_NAME[] = "MPI_Accumlate";
return MPI_SUCCESS;
int MPI_Accumulate(void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
int target_rank, MPI_Aint target_disp, int target_count,
MPI_Datatype target_datatype, MPI_Op op, MPI_Win win)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

2
src/mpi/c/add_error_class.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Add_error_class";
static const char FUNC_NAME[] = "MPI_Add_error_class";
int MPI_Add_error_class(int *errorclass)

2
src/mpi/c/add_error_code.c
Просмотреть файл

@ -19,7 +19,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Add_error_code";
static const char FUNC_NAME[] = "MPI_Add_error_code";
int MPI_Add_error_code(int errorclass, int *errorcode)

2
src/mpi/c/add_error_string.c
Просмотреть файл

@ -19,7 +19,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Add_error_code";
static const char FUNC_NAME[] = "MPI_Add_error_code";
int MPI_Add_error_string(int errorcode, char *string)

12
src/mpi/c/address.c
Просмотреть файл

@ -21,14 +21,16 @@
static const char FUNC_NAME[] = "MPI_Address";
int MPI_Address(void *location, MPI_Aint *address)
{
if( MPI_PARAM_CHECK ) {
if( OMPI_MPI_INVALID_STATE ) {
OMPI_ERRHANDLER_RETURN( MPI_ERR_INTERN, (ompi_communicator_t*)NULL,
MPI_ERR_INTERN, FUNC_NAME );
}
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == location || NULL == address) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME);
}
}
*address = (MPI_Aint)location;
return MPI_SUCCESS;
return MPI_SUCCESS;
}

2
src/mpi/c/allgatherv.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Allgatherv";
static const char FUNC_NAME[] = "MPI_Allgatherv";
int MPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,

20
src/mpi/c/alloc_mem.c
Просмотреть файл

@ -8,6 +8,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Alloc_mem = PMPI_Alloc_mem
@ -17,13 +19,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Alloc_mem";
int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr)
{
if (size < 0) {
/* Return error on MPI_COMM_WORLD */
}
if (NULL == baseptr) {
/* Return error on MPI_COMM_WORLD */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (size < 0 || NULL == baseptr) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
FUNC_NAME);
}
}
/* Check the MPI_Info and see if we requested a specific MCA
@ -33,5 +39,7 @@ int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr)
If either fails, return an error on MPI_COMM_WORLD. */
return MPI_SUCCESS;
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

2
src/mpi/c/allreduce.c
Просмотреть файл

@ -19,7 +19,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Allreduce";
static const char FUNC_NAME[] = "MPI_Allreduce";
int MPI_Allreduce(void *sendbuf, void *recvbuf, int count,

2
src/mpi/c/alltoallv.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Alltoallv";
static const char FUNC_NAME[] = "MPI_Alltoallv";
int MPI_Alltoallv(void *sendbuf, int *sendcounts, int *sdispls,

2
src/mpi/c/alltoallw.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Alltoallw";
static const char FUNC_NAME[] = "MPI_Alltoallw";
int MPI_Alltoallw(void *sendbuf, int *sendcounts, int *sdispls,

2
src/mpi/c/attr_delete.c
Просмотреть файл

@ -19,11 +19,13 @@
static const char FUNC_NAME[] = "MPI_Attr_delete";
int MPI_Attr_delete(MPI_Comm comm, int keyval)
{
int ret;
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);

1
src/mpi/c/attr_get.c
Просмотреть файл

@ -24,6 +24,7 @@ int MPI_Attr_get(MPI_Comm comm, int keyval, void *attribute_val, int *flag)
int ret;
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ((NULL == attribute_val) || (NULL == flag)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
FUNC_NAME);

1
src/mpi/c/attr_put.c
Просмотреть файл

@ -24,6 +24,7 @@ int MPI_Attr_put(MPI_Comm comm, int keyval, void *attribute_val)
int ret;
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);

6
src/mpi/c/bindings.h
Просмотреть файл

@ -26,14 +26,14 @@ extern bool ompi_mpi_param_check;
*/
#define OMPI_CHECK_DATATYPE_FOR_SEND( RC, DDT, COUNT ) \
do { \
if( (DDT) == MPI_DATATYPE_NULL ) (RC) = MPI_ERR_TYPE; \
if( NULL == (DDT) || MPI_DATATYPE_NULL == (DDT) ) (RC) = MPI_ERR_TYPE; \
else if( (COUNT) < 0 ) (RC) = MPI_ERR_COUNT; \
else if( !ompi_ddt_is_committed((DDT)) ) (RC) = MPI_ERR_TYPE; \
} while (0)
#define OMPI_CHECK_DATATYPE_FOR_RECV( RC, DDT, COUNT ) \
do { \
if( (DDT) == MPI_DATATYPE_NULL ) (RC) = MPI_ERR_TYPE; \
if( NULL == (DDT) || MPI_DATATYPE_NULL == (DDT) ) (RC) = MPI_ERR_TYPE; \
else if( (COUNT) < 0 ) (RC) = MPI_ERR_COUNT; \
else if( !ompi_ddt_is_committed((DDT)) ) (RC) = MPI_ERR_TYPE; \
else if( ompi_ddt_is_overerlapped((DDT)) ) (RC) = MPI_ERR_TYPE; \
@ -41,7 +41,7 @@ do { \
#define OMPI_CHECK_DATATYPE_FOR_ONE_SIDED( RC, DDT, COUNT ) \
do { \
if( (DDT) == MPI_DATATYPE_NULL ) (RC) = MPI_ERR_TYPE; \
if( NULL == (DDT) || MPI_DATATYPE_NULL == (DDT) ) (RC) = MPI_ERR_TYPE; \
else if( (COUNT) < 0 ) (RC) = MPI_ERR_COUNT; \
else if( !ompi_ddt_is_committed((DDT)) ) (RC) = MPI_ERR_TYPE; \
else if( ompi_ddt_is_overerlapped((DDT)) ) (RC) = MPI_ERR_TYPE; \

13
src/mpi/c/buffer_attach.c
Просмотреть файл

@ -7,6 +7,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "runtime/runtime.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#include "mca/pml/pml.h"
#include "mca/pml/base/pml_base_bsend.h"
@ -19,9 +21,18 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Buffer_attach";
int MPI_Buffer_attach(void *buffer, int size)
{
return mca_pml_base_bsend_attach(buffer, size);
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == buffer || size < 0) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME);
}
}
return mca_pml_base_bsend_attach(buffer, size);
}

12
src/mpi/c/buffer_detach.c
Просмотреть файл

@ -18,7 +18,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Buffer_detach";
int MPI_Buffer_detach(void *buffer, int *size)
{
return mca_pml_base_bsend_detach(buffer, size);
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == buffer || NULL == size || *size < 0) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME);
}
}
return mca_pml_base_bsend_detach(buffer, size);
}

10
src/mpi/c/cancel.c
Просмотреть файл

@ -8,6 +8,8 @@
#include "runtime/runtime.h"
#include "mpi/c/bindings.h"
#include "mca/pml/pml.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Cancel = PMPI_Cancel
@ -17,14 +19,16 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Cancel";
int MPI_Cancel(MPI_Request *request)
{
int rc;
if ( MPI_PARAM_CHECK ) {
rc = MPI_SUCCESS;
if ( OMPI_MPI_INVALID_STATE ) {
rc = MPI_ERR_INTERN;
} else if (request == NULL) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (request == NULL) {
rc = MPI_ERR_REQUEST;
}
/* JMS: Tim will fix to invoke on the communicator/window/file

18
src/mpi/c/cart_coords.c
Просмотреть файл

@ -19,31 +19,35 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Cart_coords";
int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords) {
int err;
mca_topo_base_cart_coords_fn_t func;
/* check the arguments */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_coords");
FUNC_NAME);
}
if (OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_coords");
FUNC_NAME);
}
if (!OMPI_COMM_IS_CART(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
"MPI_Cart_coords");
FUNC_NAME);
}
if ( (0 > maxdims) || ((0 < maxdims) && (NULL == coords))) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_coords");
FUNC_NAME);
}
if ((0 > rank) || (rank > ompi_group_size(comm->c_local_group))) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_RANK,
"MPI_Cart_coords");
FUNC_NAME);
}
}
@ -51,12 +55,12 @@ int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords) {
func = comm->c_topo->topo_cart_coords;
if (NULL == func) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER,
"MPI_Cart_coords");
FUNC_NAME);
}
/* call the function */
if ( MPI_SUCCESS !=
(err = func(comm, rank, maxdims, coords))) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_coords");
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
}
/* all done */

18
src/mpi/c/cart_create.c
Просмотреть файл

@ -18,6 +18,9 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Cart_create";
int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
int *periods, int reorder, MPI_Comm *comm_cart) {
@ -26,25 +29,26 @@ int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
/* check the arguments */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == old_comm) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_create");
FUNC_NAME);
}
if (OMPI_COMM_IS_INTER(old_comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_create");
FUNC_NAME);
}
if (1 > ndims) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_create");
FUNC_NAME);
}
if (NULL == dims || NULL == periods || NULL == comm_cart) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_create");
FUNC_NAME);
}
if (0 > reorder || 1 < reorder) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_create");
FUNC_NAME);
}
/* check if the number of processes on the grid are corrct */
@ -61,7 +65,7 @@ int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
if (parent_procs < count_nodes) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_create");
FUNC_NAME);
}
}
}
@ -83,7 +87,7 @@ int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
/* check the error status */
if (MPI_SUCCESS != err) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_create");
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
}
/* All done */

17
src/mpi/c/cart_get.c
Просмотреть файл

@ -18,6 +18,9 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Cart_get";
int MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims,
int *periods, int *coords) {
/* local variables */
@ -26,31 +29,33 @@ int MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims,
/* check the arguments */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm || OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_get");
FUNC_NAME);
}
if (!OMPI_COMM_IS_CART(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
"MPI_Cart_get");
FUNC_NAME);
}
if ((0 > maxdims) || (0 < maxdims &&
((NULL == dims) || (NULL == periods) || (NULL == coords)))) {
((NULL == dims) || (NULL == periods) ||
(NULL == coords)))) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_get");
FUNC_NAME);
}
}
/* get the function pointer to do the right thing */
func = comm->c_topo->topo_cart_get;
if (NULL == func) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER,
"MPI_Cart_get");
FUNC_NAME);
}
/* all arguments are checked and now call the back end function */
if ( MPI_SUCCESS !=
(err = func(comm, maxdims, dims, periods, coords))) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_get");
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
}
/* All done */

16
src/mpi/c/cart_map.c
Просмотреть файл

@ -18,6 +18,9 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Cart_map";
int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims,
int *periods, int *newrank) {
int err;
@ -25,21 +28,22 @@ int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims,
/* check the arguments */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_map");
FUNC_NAME);
}
if (OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_map");
FUNC_NAME);
}
if(!OMPI_COMM_IS_CART(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
"MPI_Cart_map");
FUNC_NAME);
}
if ((NULL == dims) || (NULL == periods) || (NULL == newrank)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_map");
FUNC_NAME);
}
}
@ -47,12 +51,12 @@ int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims,
func = comm->c_topo->topo_cart_map;
if (NULL == func) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER,
"MPI_Cart_map");
FUNC_NAME);
}
/* call the function */
if ( MPI_SUCCESS !=
(err = func(comm, ndims, dims, periods, newrank))) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_map");
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
}
return MPI_SUCCESS;

15
src/mpi/c/cart_rank.c
Просмотреть файл

@ -18,6 +18,8 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Cart_rank";
int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank) {
int err;
@ -25,21 +27,22 @@ int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank) {
/* check the arguments */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_rank");
FUNC_NAME);
}
if (OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_rank");
FUNC_NAME);
}
if (!OMPI_COMM_IS_CART(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
"MPI_Cart_rank");
FUNC_NAME);
}
if ((NULL == coords) || (NULL == rank)){
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_rank");
FUNC_NAME);
}
}
@ -47,12 +50,12 @@ int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank) {
func = comm->c_topo->topo_cart_rank;
if (NULL == func) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER,
"MPI_Cart_rank");
FUNC_NAME);
}
/* call the function */
if ( MPI_SUCCESS !=
(err = func(comm, coords, rank))) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_rank");
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
}
return MPI_SUCCESS;

18
src/mpi/c/cart_shift.c
Просмотреть файл

@ -18,6 +18,9 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Cart_shift";
int MPI_Cart_shift(MPI_Comm comm, int direction, int disp,
int *rank_source, int *rank_dest) {
int err;
@ -25,25 +28,26 @@ int MPI_Cart_shift(MPI_Comm comm, int direction, int disp,
/* check the arguments */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_shift");
FUNC_NAME);
}
if (OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_shift");
FUNC_NAME);
}
if (!OMPI_COMM_IS_CART(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
"MPI_Cart_shift");
FUNC_NAME);
}
if (0 > direction) { /* yet to detect direction >= comm->c_topo_ndims */
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_DIMS,
"MPI_Cart_shift");
FUNC_NAME);
}
if (NULL == rank_source || NULL == rank_dest) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_shift");
FUNC_NAME);
}
}
@ -51,12 +55,12 @@ int MPI_Cart_shift(MPI_Comm comm, int direction, int disp,
func = comm->c_topo->topo_cart_shift;
if (NULL == func) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER,
"MPI_Cart_shift");
FUNC_NAME);
}
/* call the function */
if ( MPI_SUCCESS !=
(err = func(comm, direction, disp, rank_source, rank_dest))) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_shift");
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
}
/* all done */

15
src/mpi/c/cart_sub.c
Просмотреть файл

@ -18,6 +18,8 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Cart_sub";
int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm) {
int err;
@ -25,21 +27,22 @@ int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm) {
/* check the arguments */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_sub");
FUNC_NAME);
}
if (OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Cart_sub");
FUNC_NAME);
}
if (!OMPI_COMM_IS_CART(comm)) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
"MPI_Cart_sub");
FUNC_NAME);
}
if (NULL == remain_dims || NULL == new_comm) {
return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Cart_sub");
FUNC_NAME);
}
}
@ -47,12 +50,12 @@ int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm) {
func = comm->c_topo->topo_cart_sub;
if (NULL == func) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER,
"MPI_Cart_sub");
FUNC_NAME);
}
/* call the function */
if ( MPI_SUCCESS !=
(err = func(comm, remain_dims, new_comm))) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_sub");
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
}
/* all done */

16
src/mpi/c/cartdim_get.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Cartdim_get = PMPI_Cartdim_get
@ -16,6 +18,16 @@
#endif
int MPI_Cartdim_get(MPI_Comm comm, int *ndims) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_Cartdim_get";
int MPI_Cartdim_get(MPI_Comm comm, int *ndims)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

8
src/mpi/c/close_port.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Close_port";
static const char FUNC_NAME[] = "MPI_Close_port";
int MPI_Close_port(char *port_name)
@ -27,7 +27,7 @@ int MPI_Close_port(char *port_name)
if ( NULL == port_name )
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Close_port");
FUNC_NAME);
}
/* As far as I can see at the moment, this is an empty function.
@ -35,5 +35,7 @@ int MPI_Close_port(char *port_name)
therefore we don't have to free an 'address'.
*/
return MPI_SUCCESS;
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

14
src/mpi/c/comm_accept.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_accept";
static const char FUNC_NAME[] = "MPI_Comm_accept";
int MPI_Comm_accept(char *port_name, MPI_Info info, int root,
@ -35,18 +35,22 @@ int MPI_Comm_accept(char *port_name, MPI_Info info, int root,
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
if ( OMPI_COMM_IS_INTER(comm))
}
if ( OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM,
FUNC_NAME);
if ( 0 > root || ompi_comm_size(comm) < root )
}
if ( 0 > root || ompi_comm_size(comm) < root ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == newcomm )
}
if ( NULL == newcomm ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
rank = ompi_comm_rank ( comm );

9
src/mpi/c/comm_c2f.c
Просмотреть файл

@ -18,18 +18,19 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Comm_c2f";
MPI_Fint MPI_Comm_c2f(MPI_Comm comm)
{
ompi_communicator_t *cptr=(ompi_communicator_t *)comm;
if ( MPI_PARAM_CHECK) {
if ( ompi_mpi_finalized )
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN,
"MPI_Comm_c2f");
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( ompi_comm_invalid (cptr))
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Comm_c2f");
FUNC_NAME);
}
/* Since MPI_COMM_NULL is an object itself, we do not have to check

15
src/mpi/c/comm_call_errhandler.c
Просмотреть файл

@ -18,20 +18,23 @@
#endif
static const char FUNC_NAME[] = "MPI_Comm_call_errhandler";
int MPI_Comm_call_errhandler(MPI_Comm comm, int errorcode)
{
/* Error checking */
if (MPI_PARAM_CHECK) {
if (NULL == comm ||
MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Comm_call_errhandler");
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (ompi_comm_invalid(comm)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
}
}
/* Invoke the errhandler */
return OMPI_ERRHANDLER_INVOKE(comm, errorcode,
"MPI_Comm_call_errhandler");
return OMPI_ERRHANDLER_INVOKE(comm, errorcode, FUNC_NAME);
}

2
src/mpi/c/comm_compare.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_compare";
static const char FUNC_NAME[] = "MPI_Comm_compare";
int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result) {

14
src/mpi/c/comm_connect.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_connect";
static const char FUNC_NAME[] = "MPI_Comm_connect";
int MPI_Comm_connect(char *port_name, MPI_Info info, int root,
@ -35,18 +35,22 @@ int MPI_Comm_connect(char *port_name, MPI_Info info, int root,
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
if ( OMPI_COMM_IS_INTER(comm))
}
if ( OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM,
FUNC_NAME);
if ( 0 > root || ompi_comm_size(comm) < root )
}
if ( 0 > root || ompi_comm_size(comm) < root ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == newcomm )
}
if ( NULL == newcomm ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
rank = ompi_comm_rank ( comm );

2
src/mpi/c/comm_create.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_create";
static const char FUNC_NAME[] = "MPI_Comm_create";
int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm) {

10
src/mpi/c/comm_create_errhandler.c
Просмотреть файл

@ -18,6 +18,9 @@
#endif
static const char FUNC_NAME[] = "MPI_Comm_create_errhandler";
int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function,
MPI_Errhandler *errhandler)
{
@ -26,10 +29,12 @@ int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function,
/* Error checking */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == function ||
NULL == errhandler) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Comm_create_errhandler");
FUNC_NAME);
}
}
@ -42,6 +47,5 @@ int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function,
err = MPI_ERR_INTERN;
}
OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, MPI_ERR_INTERN,
"MPI_Comm_create_errhandler");
OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

2
src/mpi/c/comm_create_keyval.c
Просмотреть файл

@ -18,6 +18,7 @@
static const char FUNC_NAME[] = "MPI_Comm_create_keyval";
int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function *comm_copy_attr_fn,
MPI_Comm_delete_attr_function *comm_delete_attr_fn,
int *comm_keyval, void *extra_state)
@ -27,6 +28,7 @@ int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function *comm_copy_attr_fn,
ompi_attribute_fn_ptr_union_t del_fn;
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ((NULL == comm_copy_attr_fn) || (NULL == comm_delete_attr_fn) ||
(NULL == comm_keyval)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,

2
src/mpi/c/comm_delete_attr.c
Просмотреть файл

@ -18,11 +18,13 @@
static const char FUNC_NAME[] = "MPI_Comm_delete_attr";
int MPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval)
{
int ret;
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);

2
src/mpi/c/comm_disconnect.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_disconnect";
static const char FUNC_NAME[] = "MPI_Comm_disconnect";
int MPI_Comm_disconnect(MPI_Comm *comm)

6
src/mpi/c/comm_dup.c
Просмотреть файл

@ -17,11 +17,11 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_dup";
static const char FUNC_NAME[] = "MPI_Comm_dup";
int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm) {
int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm)
{
/* local variables */
ompi_communicator_t *comp, *newcomp;
int rsize, mode, rc=MPI_SUCCESS;

2
src/mpi/c/comm_f2c.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_f2c";
static const char FUNC_NAME[] = "MPI_Comm_f2c";
MPI_Comm MPI_Comm_f2c(MPI_Fint comm)

2
src/mpi/c/comm_free.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_free";
static const char FUNC_NAME[] = "MPI_Comm_free";
int MPI_Comm_free(MPI_Comm *comm) {

2
src/mpi/c/comm_free_keyval.c
Просмотреть файл

@ -18,6 +18,7 @@
static const char FUNC_NAME[] = "MPI_Comm_free_keyval";
int MPI_Comm_free_keyval(int *comm_keyval)
{
int ret;
@ -25,6 +26,7 @@ int MPI_Comm_free_keyval(int *comm_keyval)
/* Check for valid key pointer */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == comm_keyval) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
FUNC_NAME);

2
src/mpi/c/comm_get_attr.c
Просмотреть файл

@ -18,12 +18,14 @@
static const char FUNC_NAME[] = "MPI_Comm_get_attr";
int MPI_Comm_get_attr(MPI_Comm comm, int comm_keyval,
void *attribute_val, int *flag)
{
int ret;
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ((NULL == attribute_val) || (NULL == flag)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
FUNC_NAME);

8
src/mpi/c/comm_get_errhandler.c
Просмотреть файл

@ -18,18 +18,22 @@
#endif
static const char FUNC_NAME[] = "MPI_Comm_get_errhandler";
int MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler *errhandler)
{
/* Error checking */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == comm ||
MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Comm_get_errhandler");
FUNC_NAME);
} else if (NULL == errhandler) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Comm_get_errhandler");
FUNC_NAME);
}
}

2
src/mpi/c/comm_get_name.c
Просмотреть файл

@ -21,7 +21,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_get_name";
static const char FUNC_NAME[] = "MPI_Comm_get_name";
int MPI_Comm_get_name(MPI_Comm comm, char *name, int *length) {

17
src/mpi/c/comm_get_parent.c
Просмотреть файл

@ -17,16 +17,19 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Comm_get_parent";
int MPI_Comm_get_parent(MPI_Comm *parent)
{
if ( MPI_PARAM_CHECK ) {
if ( ompi_mpi_finalized )
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN,
"MPI_Comm_get_parent");
if ( NULL == parent )
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( NULL == parent ) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_Comm_get_parent");
FUNC_NAME);
}
}
/*
* ompi_mpi_comm_parent is MPI_COMM_NULL, in case this
@ -40,5 +43,7 @@ int MPI_Comm_get_parent(MPI_Comm *parent)
*parent = &ompi_mpi_comm_null;
*/
return MPI_SUCCESS;
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

2
src/mpi/c/comm_group.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_group";
static const char FUNC_NAME[] = "MPI_Comm_group";
int MPI_Comm_group(MPI_Comm comm, MPI_Group *group) {

5
src/mpi/c/comm_join.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_join";
static const char FUNC_NAME[] = "MPI_Comm_join";
int MPI_Comm_join(int fd, MPI_Comm *intercomm)
@ -32,9 +32,10 @@ int MPI_Comm_join(int fd, MPI_Comm *intercomm)
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( NULL == intercomm )
if ( NULL == intercomm ) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
FUNC_NAME);
}
}
/* sendrecv OOB-name (port-name) through the socket connection.

2
src/mpi/c/comm_rank.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_rank";
static const char FUNC_NAME[] = "MPI_Comm_rank";
int MPI_Comm_rank(MPI_Comm comm, int *rank)

24
src/mpi/c/comm_remote_group.c
Просмотреть файл

@ -10,7 +10,6 @@
#include "runtime/runtime.h"
#include "communicator/communicator.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Comm_remote_group = PMPI_Comm_remote_group
#endif
@ -20,29 +19,32 @@
#endif
static const char FUNC_NAME[] = "MPI_Comm_remote_group";
int MPI_Comm_remote_group(MPI_Comm comm, MPI_Group *group)
{
if ( MPI_PARAM_CHECK ) {
if ( ompi_mpi_finalized )
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN,
"MPI_Comm_remote_group");
if (MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Comm_remote_group");
FUNC_NAME);
}
if ( NULL == group )
if ( NULL == group ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
"MPI_Comm_remote_group");
FUNC_NAME);
}
}
if ( OMPI_COMM_IS_INTER(comm) ) {
OBJ_RETAIN(comm->c_remote_group);
}
else
else {
return OMPI_ERRHANDLER_INVOKE (comm, MPI_ERR_COMM,
"MPI_Comm_remote_group");
FUNC_NAME);
}
*group = (MPI_Group) comm->c_remote_group;
return MPI_SUCCESS;

18
src/mpi/c/comm_remote_size.c
Просмотреть файл

@ -18,20 +18,22 @@
#endif
static const char FUNC_NAME[] = "MPI_Comm_remote_size";
int MPI_Comm_remote_size(MPI_Comm comm, int *size) {
if ( MPI_PARAM_CHECK ) {
if ( ompi_mpi_finalized )
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN,
"MPI_Comm_remote_size");
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
if (MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
"MPI_Comm_remote_size");
FUNC_NAME);
}
if ( NULL == size )
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
"MPI_Comm_remote_size");
if ( NULL == size ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, FUNC_NAME);
}
}
*size = ompi_comm_remote_size ((ompi_communicator_t*)comm);

3
src/mpi/c/comm_set_attr.c
Просмотреть файл

@ -18,11 +18,13 @@
static const char FUNC_NAME[] = "MPI_Comm_set_attr";
int MPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val)
{
int ret;
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (MPI_COMM_NULL == comm) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
@ -31,6 +33,5 @@ int MPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val)
ret = ompi_attr_set(COMM_ATTR, comm, comm->c_keyhash,
comm_keyval, attribute_val, 0);
OMPI_ERRHANDLER_RETURN(ret, comm, MPI_ERR_OTHER, FUNC_NAME);
}

2
src/mpi/c/comm_set_errhandler.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_set_errhandler";
static const char FUNC_NAME[] = "MPI_Comm_set_errhandler";
int MPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler)

8
src/mpi/c/comm_set_name.c
Просмотреть файл

@ -21,7 +21,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_set_name";
static const char FUNC_NAME[] = "MPI_Comm_set_name";
int MPI_Comm_set_name(MPI_Comm comm, char *name) {
@ -31,13 +31,15 @@ int MPI_Comm_set_name(MPI_Comm comm, char *name) {
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( MPI_COMM_NULL == comm || ompi_comm_invalid ( comm ) )
if ( MPI_COMM_NULL == comm || ompi_comm_invalid ( comm ) ) {
return OMPI_ERRHANDLER_INVOKE ( MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
}
if ( NULL == name )
if ( NULL == name ) {
return OMPI_ERRHANDLER_INVOKE ( comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
/* -- Thread safety entrance -- */

8
src/mpi/c/comm_size.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_comm_size";
static const char FUNC_NAME[] = "MPI_comm_size";
int MPI_Comm_size(MPI_Comm comm, int *size) {
@ -25,12 +25,14 @@ int MPI_Comm_size(MPI_Comm comm, int *size) {
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD,
MPI_ERR_COMM, FUNC_NAME);
}
if ( NULL == size )
if ( NULL == size ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, FUNC_NAME);
}
}
*size = ompi_comm_size((ompi_communicator_t*)comm);

26
src/mpi/c/comm_spawn.c
Просмотреть файл

@ -19,7 +19,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_spawn";
static const char FUNC_NAME[] = "MPI_Comm_spawn";
int MPI_Comm_spawn(char *command, char **argv, int maxprocs, MPI_Info info,
@ -36,35 +36,43 @@ int MPI_Comm_spawn(char *command, char **argv, int maxprocs, MPI_Info info,
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
if ( OMPI_COMM_IS_INTER(comm))
}
if ( OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM,
FUNC_NAME);
if ( 0 > root || ompi_comm_size(comm) < root )
}
if ( 0 > root || ompi_comm_size(comm) < root ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == intercomm )
}
if ( NULL == intercomm ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == array_of_errcodes )
}
if ( NULL == array_of_errcodes ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
rank = ompi_comm_rank ( comm );
if ( MPI_PARAM_CHECK ) {
if ( rank == root ) {
if ( NULL == command )
if ( NULL == command ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == argv )
}
if ( NULL == argv ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( 0 > maxprocs )
}
if ( 0 > maxprocs ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
}

51
src/mpi/c/comm_spawn_multiple.c
Просмотреть файл

@ -18,7 +18,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_spawn_multiple";
static const char FUNC_NAME[] = "MPI_Comm_spawn_multiple";
int MPI_Comm_spawn_multiple(int count, char **array_of_commands, char ***array_of_argv,
@ -37,52 +37,65 @@ int MPI_Comm_spawn_multiple(int count, char **array_of_commands, char ***array_o
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
if ( OMPI_COMM_IS_INTER(comm))
}
if ( OMPI_COMM_IS_INTER(comm)) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM,
FUNC_NAME);
if ( 0 > root || ompi_comm_size(comm) < root )
}
if ( 0 > root || ompi_comm_size(comm) < root ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == intercomm )
}
if ( NULL == intercomm ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == array_of_errcodes )
}
if ( NULL == array_of_errcodes ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
rank = ompi_comm_rank ( comm );
if ( MPI_PARAM_CHECK ) {
if ( rank == root ) {
if ( 0 > count )
if ( 0 > count ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == array_of_commands )
}
if ( NULL == array_of_commands ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == array_of_argv )
}
if ( NULL == array_of_argv ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == array_of_maxprocs )
}
if ( NULL == array_of_maxprocs ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == array_of_info )
}
if ( NULL == array_of_info ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
for ( i=0; i<count; i++ ) {
if ( NULL == array_of_commands[i] )
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( NULL == array_of_argv[i] )
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
if ( 0 > array_of_maxprocs[i] )
}
for ( i=0; i<count; i++ ) {
if ( NULL == array_of_commands[i] ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
if ( NULL == array_of_argv[i] ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
if ( 0 > array_of_maxprocs[i] ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
}
}

11
src/mpi/c/comm_split.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_split";
static const char FUNC_NAME[] = "MPI_Comm_split";
int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm) {
@ -27,17 +27,20 @@ int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm) {
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( comm == MPI_COMM_NULL || ompi_comm_invalid ( comm ))
if ( comm == MPI_COMM_NULL || ompi_comm_invalid ( comm )) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
}
if ( color < 0 && MPI_UNDEFINED != color )
if ( color < 0 && MPI_UNDEFINED != color ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
if ( NULL == newcomm )
if ( NULL == newcomm ) {
return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
rc = ompi_comm_split ( (ompi_communicator_t*)comm, color, key,

8
src/mpi/c/comm_test_inter.c
Просмотреть файл

@ -17,7 +17,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Comm_test_inter";
static const char FUNC_NAME[] = "MPI_Comm_test_inter";
int MPI_Comm_test_inter(MPI_Comm comm, int *flag) {
@ -25,13 +25,15 @@ int MPI_Comm_test_inter(MPI_Comm comm, int *flag) {
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( MPI_COMM_NULL == comm || ompi_comm_invalid ( comm ) )
if ( MPI_COMM_NULL == comm || ompi_comm_invalid ( comm ) ) {
return OMPI_ERRHANDLER_INVOKE ( MPI_COMM_WORLD, MPI_ERR_COMM,
FUNC_NAME);
}
if ( NULL == flag )
if ( NULL == flag ) {
return OMPI_ERRHANDLER_INVOKE ( comm, MPI_ERR_ARG,
FUNC_NAME);
}
}
*flag = (comm->c_flags & OMPI_COMM_INTER);

16
src/mpi/c/dims_create.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Dims_create = PMPI_Dims_create
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_Dims_create(int nnodes, int ndims, int *dims) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_Dims_create";
int MPI_Dims_create(int nnodes, int ndims, int *dims)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

3
src/mpi/c/errhandler_c2f.c
Просмотреть файл

@ -17,12 +17,15 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Errhandler_c2f";
MPI_Fint MPI_Errhandler_c2f(MPI_Errhandler errhandler)
{
/* Error checking */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == errhandler ||
MPI_ERRHANDLER_NULL == errhandler ||
OMPI_ERRHANDLER_TYPE_COMM != errhandler->eh_mpi_object_type) {

3
src/mpi/c/errhandler_create.c
Просмотреть файл

@ -15,6 +15,9 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Errhandler_create";
int MPI_Errhandler_create(MPI_Handler_function *function,
MPI_Errhandler *errhandler)
{

4
src/mpi/c/errhandler_f2c.c
Просмотреть файл

@ -17,6 +17,8 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Errhandler_f2c";
MPI_Errhandler MPI_Errhandler_f2c(MPI_Fint errhandler_f)
{
@ -25,6 +27,8 @@ MPI_Errhandler MPI_Errhandler_f2c(MPI_Fint errhandler_f)
/* Error checking */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (0 > eh_index ||
eh_index >= ompi_pointer_array_get_size(ompi_errhandler_f_to_c_table)) {
return MPI_ERRHANDLER_NULL;

3
src/mpi/c/errhandler_free.c
Просмотреть файл

@ -17,12 +17,15 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Errhandler_free";
int MPI_Errhandler_free(MPI_Errhandler *errhandler)
{
/* Error checking */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == errhandler ||
ompi_errhandler_is_intrinsic(*errhandler)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,

8
src/mpi/c/errhandler_get.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Errhandler_get = PMPI_Errhandler_get
@ -15,9 +17,15 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Errhandler_get";
int MPI_Errhandler_get(MPI_Comm comm, MPI_Errhandler *errhandler)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This is a deprecated -- just turn around and call the real
function */

8
src/mpi/c/errhandler_set.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_Errhandler_set = PMPI_Errhandler_set
@ -15,9 +17,15 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_Errhandler_set";
int MPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler errhandler)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This is a deprecated -- just turn around and call the real
function */

6
src/mpi/c/error_class.c
Просмотреть файл

@ -18,18 +18,18 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Error_class";
static const char FUNC_NAME[] = "MPI_Error_class";
int MPI_Error_class(int errorcode, int *errorclass)
{
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( ompi_mpi_errcode_is_invalid(errorcode))
if ( ompi_mpi_errcode_is_invalid(errorcode)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
FUNC_NAME);
}
}

5
src/mpi/c/error_string.c
Просмотреть файл

@ -19,7 +19,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Error_string";
static const char FUNC_NAME[] = "MPI_Error_string";
int MPI_Error_string(int errorcode, char *string, int *resultlen)
@ -29,9 +29,10 @@ int MPI_Error_string(int errorcode, char *string, int *resultlen)
if ( MPI_PARAM_CHECK ) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if ( ompi_mpi_errcode_is_invalid(errorcode))
if ( ompi_mpi_errcode_is_invalid(errorcode)) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
FUNC_NAME);
}
}
tmpstring = ompi_mpi_errcode_get_string (errorcode);

2
src/mpi/c/exscan.c
Просмотреть файл

@ -19,7 +19,7 @@
#include "mpi/c/profile/defines.h"
#endif
static char FUNC_NAME[] = "MPI_Exscan";
static const char FUNC_NAME[] = "MPI_Exscan";
int MPI_Exscan(void *sendbuf, void *recvbuf, int count,

16
src/mpi/c/file_c2f.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_c2f = PMPI_File_c2f
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
MPI_Fint MPI_File_c2f(MPI_File file) {
return (MPI_Fint)0;
static const char FUNC_NAME[] = "MPI_File_c2f";
MPI_Fint MPI_File_c2f(MPI_File file)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return (MPI_Fint) OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

13
src/mpi/c/file_call_errhandler.c
Просмотреть файл

@ -18,19 +18,22 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_call_errhandler(MPI_File fh, int errorcode) {
static const char FUNC_NAME[] = "MPI_File_call_errhandler";
int MPI_File_call_errhandler(MPI_File fh, int errorcode)
{
/* Error checking */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == fh ||
MPI_FILE_NULL == fh) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
"MPI_File_call_errhandler");
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME);
}
}
/* Invoke the errhandler */
return OMPI_ERRHANDLER_INVOKE(fh, errorcode,
"MPI_File_call_errhandler");
return OMPI_ERRHANDLER_INVOKE(fh, errorcode, FUNC_NAME);
}

16
src/mpi/c/file_close.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_close = PMPI_File_close
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_close(MPI_File *fh) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_close";
int MPI_File_close(MPI_File *fh)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

4
src/mpi/c/file_create_errhandler.c
Просмотреть файл

@ -18,6 +18,9 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_create_errhandler";
int MPI_File_create_errhandler(MPI_File_errhandler_fn *function,
MPI_Errhandler *errhandler) {
int err = MPI_SUCCESS;
@ -25,6 +28,7 @@ int MPI_File_create_errhandler(MPI_File_errhandler_fn *function,
/* Error checking */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == function ||
NULL == errhandler) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,

16
src/mpi/c/file_delete.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_delete = PMPI_File_delete
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_delete(char *filename, MPI_Info info) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_delete";
int MPI_File_delete(char *filename, MPI_Info info)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_f2c.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_f2c = PMPI_File_f2c
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
MPI_File MPI_File_f2c(MPI_Fint file) {
return (MPI_File)0;
static const char FUNC_NAME[] = "MPI_File_f2c";
MPI_File MPI_File_f2c(MPI_Fint file)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return (MPI_File) OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_get_amode.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_amode = PMPI_File_get_amode
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_get_amode(MPI_File fh, int *amode) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_get_amode";
int MPI_File_get_amode(MPI_File fh, int *amode)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_get_atomicity.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_atomicity = PMPI_File_get_atomicity
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_get_atomicity(MPI_File fh, int *flag) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_get_atomicity";
int MPI_File_get_atomicity(MPI_File fh, int *flag)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_get_byte_offset.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_byte_offset = PMPI_File_get_byte_offset
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_get_byte_offset";
int MPI_File_get_byte_offset(MPI_File fh, MPI_Offset offset,
MPI_Offset *disp) {
return MPI_SUCCESS;
MPI_Offset *disp)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

10
src/mpi/c/file_get_errhandler.c
Просмотреть файл

@ -18,13 +18,18 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_get_errhandler( MPI_File file, MPI_Errhandler *errhandler) {
static const char FUNC_NAME[] = "MPI_File_get_errhandler";
int MPI_File_get_errhandler( MPI_File file, MPI_Errhandler *errhandler)
{
/* Error checking */
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
if (NULL == file ||
MPI_FILE_NULL == file) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_FILE,
"MPI_File_get_errhandler");
} else if (NULL == errhandler) {
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
@ -38,5 +43,6 @@ int MPI_File_get_errhandler( MPI_File file, MPI_Errhandler *errhandler) {
*errhandler = file->error_handler;
/* All done */
return MPI_SUCCESS;
}

16
src/mpi/c/file_get_group.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_group = PMPI_File_get_group
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_get_group(MPI_File fh, MPI_Group *group) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_get_group";
int MPI_File_get_group(MPI_File fh, MPI_Group *group)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_get_info.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_info = PMPI_File_get_info
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_get_info(MPI_File fh, MPI_Info *info_used) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_get_info";
int MPI_File_get_info(MPI_File fh, MPI_Info *info_used)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_get_position.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_position = PMPI_File_get_position
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_get_position(MPI_File fh, MPI_Offset *offset) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_get_position";
int MPI_File_get_position(MPI_File fh, MPI_Offset *offset)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_get_position_shared.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_position_shared = PMPI_File_get_position_shared
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_get_position_shared(MPI_File fh, MPI_Offset *offset) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_get_position_shared";
int MPI_File_get_position_shared(MPI_File fh, MPI_Offset *offset)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_get_size.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_size = PMPI_File_get_size
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_get_size(MPI_File fh, MPI_Offset *size) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_get_size";
int MPI_File_get_size(MPI_File fh, MPI_Offset *size)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_get_type_extent.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_type_extent = PMPI_File_get_type_extent
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_get_type_extent";
int MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype,
MPI_Aint *extent) {
return MPI_SUCCESS;
MPI_Aint *extent)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

18
src/mpi/c/file_get_view.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_get_view = PMPI_File_get_view
@ -15,8 +17,18 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_get_view";
int MPI_File_get_view(MPI_File fh, MPI_Offset *disp,
MPI_Datatype *etype,
MPI_Datatype *filetype, char *datarep) {
return MPI_SUCCESS;
MPI_Datatype *etype,
MPI_Datatype *filetype, char *datarep)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_iread.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_iread = PMPI_File_iread
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_iread";
int MPI_File_iread(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Request *request) {
return MPI_SUCCESS;
datatype, MPI_Request *request)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

17
src/mpi/c/file_iread_at.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_iread_at = PMPI_File_iread_at
@ -15,8 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_iread_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Request *request) {
static const char FUNC_NAME[] = "MPI_File_iread_at";
return MPI_SUCCESS;
int MPI_File_iread_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Request *request)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_iread_shared.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_iread_shared = PMPI_File_iread_shared
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_iread_shared";
int MPI_File_iread_shared(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Request *request) {
return MPI_SUCCESS;
MPI_Datatype datatype, MPI_Request *request)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_iwrite.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_iwrite = PMPI_File_iwrite
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_iwrite";
int MPI_File_iwrite(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Request *request) {
return MPI_SUCCESS;
datatype, MPI_Request *request)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_iwrite_at.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_iwrite_at = PMPI_File_iwrite_at
@ -15,8 +17,18 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_iwrite_at";
int MPI_File_iwrite_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPI_Request *request) {
return MPI_SUCCESS;
MPI_Request *request)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_iwrite_shared.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_iwrite_shared = PMPI_File_iwrite_shared
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_iwrite_shared";
int MPI_File_iwrite_shared(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Request *request) {
return MPI_SUCCESS;
MPI_Datatype datatype, MPI_Request *request)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_open.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_open = PMPI_File_open
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_open";
int MPI_File_open(MPI_Comm comm, char *filename, int amode,
MPI_Info info, MPI_File *fh) {
return MPI_SUCCESS;
MPI_Info info, MPI_File *fh)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_preallocate.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_preallocate = PMPI_File_preallocate
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_preallocate(MPI_File fh, MPI_Offset size) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_preallocate";
int MPI_File_preallocate(MPI_File fh, MPI_Offset size)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_read.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_read = PMPI_File_read
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_read";
int MPI_File_read(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status) {
return MPI_SUCCESS;
datatype, MPI_Status *status)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_read_all.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_read_all = PMPI_File_read_all
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_read_all";
int MPI_File_read_all(MPI_File fh, void *buf, int count, MPI_Datatype
datatype, MPI_Status *status) {
return MPI_SUCCESS;
datatype, MPI_Status *status)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_read_all_begin.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_read_all_begin = PMPI_File_read_all_begin
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_read_all_begin";
int MPI_File_read_all_begin(MPI_File fh, void *buf, int count,
MPI_Datatype datatype) {
return MPI_SUCCESS;
MPI_Datatype datatype)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_read_all_end.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_read_all_end = PMPI_File_read_all_end
@ -15,6 +17,16 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status) {
return MPI_SUCCESS;
static const char FUNC_NAME[] = "MPI_File_read_all_end";
int MPI_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

17
src/mpi/c/file_read_at.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_read_at = PMPI_File_read_at
@ -15,8 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
int MPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status) {
static const char FUNC_NAME[] = "MPI_File_read_at";
return MPI_SUCCESS;
int MPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype, MPI_Status *status)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

18
src/mpi/c/file_read_at_all.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_read_at_all = PMPI_File_read_at_all
@ -15,8 +17,18 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_read_at_all";
int MPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPI_Status *status) {
return MPI_SUCCESS;
int count, MPI_Datatype datatype,
MPI_Status *status)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

16
src/mpi/c/file_read_at_all_begin.c
Просмотреть файл

@ -6,6 +6,8 @@
#include "mpi.h"
#include "mpi/c/bindings.h"
#include "communicator/communicator.h"
#include "errhandler/errhandler.h"
#if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
#pragma weak MPI_File_read_at_all_begin = PMPI_File_read_at_all_begin
@ -15,7 +17,17 @@
#include "mpi/c/profile/defines.h"
#endif
static const char FUNC_NAME[] = "MPI_File_read_at_all_begin";
int MPI_File_read_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype) {
return MPI_SUCCESS;
int count, MPI_Datatype datatype)
{
if (MPI_PARAM_CHECK) {
OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
}
/* This function is not yet implemented */
return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
}

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше