/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
* (C) 2001 by Argonne National Laboratory.
* See COPYRIGHT in top-level directory.
*/
#ifndef MPIERRS_H_INCLUDED
#define MPIERRS_H_INCLUDED
/* ------------------------------------------------------------------------- */
/* mpierrs.h */
/* ------------------------------------------------------------------------- */
/*
=== BEGIN_MPI_T_CVAR_INFO_BLOCK ===
cvars:
- name : MPIR_CVAR_COLL_ALIAS_CHECK
category : COLLECTIVE
type : int
default : 1
class : device
verbosity : MPI_T_VERBOSITY_USER_BASIC
scope : MPI_T_SCOPE_ALL_EQ
description : >-
Enable checking of aliasing in collective operations
=== END_MPI_T_CVAR_INFO_BLOCK ===
*/
/* Error checking (see --enable-error-checking for control of this) */
#ifdef HAVE_ERROR_CHECKING
#define MPID_ERROR_LEVEL_ALL 1
#define MPID_ERROR_LEVEL_RUNTIME 2
/* Use MPID_ERROR_DECL to wrap declarations that are needed only when
error checking is turned on */
#define MPID_ERROR_DECL(a) a
#if HAVE_ERROR_CHECKING == MPID_ERROR_LEVEL_ALL
#define MPID_BEGIN_ERROR_CHECKS
#define MPID_END_ERROR_CHECKS
#define MPID_ELSE_ERROR_CHECKS
#elif HAVE_ERROR_CHECKING == MPID_ERROR_LEVEL_RUNTIME
#define MPID_BEGIN_ERROR_CHECKS if (MPIR_Process.do_error_checks) {
#define MPID_ELSE_ERROR_CHECKS }else{
#define MPID_END_ERROR_CHECKS }
#else
#error "Unknown value for error checking"
#endif
#else
#define MPID_BEGIN_ERROR_CHECKS
#define MPID_END_ERROR_CHECKS
#define MPID_ERROR_DECL(a)
#endif /* HAVE_ERROR_CHECKING */
/*
* Standardized error checking macros. These provide the correct tests for
* common tests. These set err with the encoded error value.
*/
#define MPIR_ERRTEST_SEND_TAG(tag,err) \
if ((tag) < 0 || (tag) > MPIR_Process.attrs.tag_ub) { \
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_TAG, "**tag", "**tag %d", tag); \
goto fn_fail; \
}
#define MPIR_ERRTEST_RECV_TAG(tag,err) \
if ((tag) < MPI_ANY_TAG || (tag) > MPIR_Process.attrs.tag_ub) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_TAG, "**tag", "**tag %d", tag ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_RANK(comm_ptr,rank,err) \
if ((rank) < 0 || (rank) >= (comm_ptr)->remote_size) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_RANK, "**rank", "**rank %d %d", rank, \
(comm_ptr)->remote_size ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_SEND_RANK(comm_ptr,rank,err) \
if ((rank) < MPI_PROC_NULL || (rank) >= (comm_ptr)->remote_size) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_RANK, "**rank", "**rank %d %d", rank, \
(comm_ptr)->remote_size ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_RECV_RANK(comm_ptr,rank,err) \
if ((rank) < MPI_ANY_SOURCE || (rank) >= (comm_ptr)->remote_size) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_RANK, "**rank", "**rank %d %d", rank, \
(comm_ptr)->remote_size ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_COUNT(count,err) \
if ((count) < 0) { \
err = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_COUNT, \
"**countneg", \
"**countneg %d", \
count ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_DISP(disp,err) \
if ((disp) < 0) { \
err = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_DISP, \
"**rmadisp", 0 ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_ALIAS(ptr1,ptr2,err) \
if ((ptr1)==(ptr2) && (ptr1) != MPI_BOTTOM) { \
err = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_BUFFER, \
"**bufalias", 0 ); \
goto fn_fail; \
}
/* FIXME this test is probably too broad. Comparing the (buffer,type,count)
* tuples is really what is needed to check for aliasing. */
#define MPIR_ERRTEST_ALIAS_COLL(ptr1,ptr2,err) \
if (MPIR_CVAR_COLL_ALIAS_CHECK && (ptr1)==(ptr2)) { \
err = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_BUFFER, \
"**bufalias", 0 ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_ARGNULL(arg,arg_name,err) \
if (!(arg)) { \
err = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_ARG, \
"**nullptr", \
"**nullptr %s", \
arg_name ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_ARGNEG(arg,arg_name,err) \
if ((arg) < 0) { \
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, MPI_ERR_ARG, \
"**argneg", \
"**argneg %s %d", arg_name, arg ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_ARGNONPOS(arg,arg_name,err,errclass) \
if ((arg) <= 0) { \
err = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
errclass, \
"**argnonpos", \
"**argnonpos %s %d", \
arg_name, arg ); \
goto fn_fail; \
}
/* An intracommunicator must have a root between 0 and local_size-1. */
/* intercomm can be between MPI_PROC_NULL (or MPI_ROOT) and remote_size-1 */
#define MPIR_ERRTEST_INTRA_ROOT(comm_ptr,root,err) \
if ((root) < 0 || (root) >= (comm_ptr)->local_size) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_ROOT, "**root", "**root %d", root ); \
goto fn_fail; \
}
/* We use -2 (MPI_PROC_NULL and MPI_ROOT are negative) for the
intercomm test */
#define MPIR_ERRTEST_INTER_ROOT(comm_ptr,root,err) \
if ((root) < -3 || (root) >= (comm_ptr)->remote_size) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_ROOT, "**root", "**root %d", root ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_PERSISTENT(reqp,err) \
if ((reqp)->kind != MPID_PREQUEST_SEND && reqp->kind != MPID_PREQUEST_RECV) { \
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_REQUEST, "**requestnotpersist", 0 ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_PERSISTENT_ACTIVE(reqp,err) \
if (((reqp)->kind == MPID_PREQUEST_SEND || \
reqp->kind == MPID_PREQUEST_RECV) && reqp->partner_request != NULL) { \
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_REQUEST, "**requestpersistactive", 0 ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_COMM_INTRA(comm_ptr, err ) \
if ((comm_ptr)->comm_kind != MPID_INTRACOMM) { \
err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_COMM,"**commnotintra",0); \
goto fn_fail; \
}
#define MPIR_ERRTEST_COMM_TAG(tag,err) \
if ((tag) < 0 || (tag) > MPIR_Process.attrs.tag_ub) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_TAG, "**tag", "**tag %d", tag); \
goto fn_fail; \
}
/* Tests for totally meaningless datatypes first, then for
* MPI_DATATYPE_NULL as a separate case.
*/
#define MPIR_ERRTEST_DATATYPE(datatype, name_, err_) \
{ \
if (HANDLE_GET_MPI_KIND(datatype) != MPID_DATATYPE || \
(HANDLE_GET_KIND(datatype) == HANDLE_KIND_INVALID && \
datatype != MPI_DATATYPE_NULL)) \
{ \
err_ = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_TYPE, \
"**dtype", 0 ); \
goto fn_fail; \
} \
if (datatype == MPI_DATATYPE_NULL) \
{ \
err_ = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_TYPE, \
"**dtypenull", \
"**dtypenull %s", \
name_); \
goto fn_fail; \
} \
}
#define MPIR_ERRTEST_TYPE_RMA_ATOMIC(datatype_, err_) \
do { \
if (!MPIR_Type_is_rma_atomic(datatype_)) { \
err_ = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_TYPE, \
"**rmatypenotatomic", \
"**rmatypenotatomic %D", \
datatype); \
goto fn_fail; \
} \
} while (0)
#define MPIR_ERRTEST_WIN_FLAVOR(win_, flavor_, err_) \
do { \
if ((win_)->create_flavor != (flavor_)) { \
MPIR_ERR_SETANDSTMT1((err_), MPI_ERR_RMA_FLAVOR, \
goto fn_fail, "**winflavor", \
"**winflavor %s", #flavor_); \
} \
} while (0)
#define MPIR_ERRTEST_SENDBUF_INPLACE(sendbuf,count,err) \
if (count > 0 && sendbuf == MPI_IN_PLACE) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_BUFFER, "**sendbuf_inplace", 0 ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_RECVBUF_INPLACE(recvbuf,count,err) \
if (count > 0 && recvbuf == MPI_IN_PLACE) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_BUFFER, "**recvbuf_inplace", 0 ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_BUF_INPLACE(buf,count,err) \
if (count > 0 && buf == MPI_IN_PLACE) { \
err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \
MPI_ERR_BUFFER, "**buf_inplace", 0 ); \
goto fn_fail; \
}
#define MPIR_ERRTEST_NAMED_BUF_INPLACE(buf, bufname, count, err) \
do { \
if (count > 0 && buf == MPI_IN_PLACE) { \
MPIR_ERR_SETANDJUMP1(err, MPI_ERR_BUFFER, "**buf_inplace", \
"**buf_inplace %s", bufname); \
} \
} while (0)
/*
* Check that the triple (buf,count,datatype) does not specify a null
* buffer. This does not guarantee that the buffer is valid but does
* catch the most common problems.
* Question:
* Should this be an (inlineable) routine?
* Since it involves extracting the datatype pointer for non-builtin
* datatypes, should it take a dtypeptr argument (valid only if not
* builtin)?
*/
#define MPIR_ERRTEST_USERBUFFER(buf,count,dtype,err) \
if (count > 0 && buf == 0) { \
int ferr = 0; \
if (HANDLE_GET_KIND(dtype) == HANDLE_KIND_BUILTIN) { ferr=1; } \
else { \
MPI_Aint errsize; \
MPID_Datatype *errdtypeptr; \
MPID_Datatype_get_ptr(dtype,errdtypeptr); \
MPID_Datatype_get_size_macro(dtype,errsize); \
if (errdtypeptr && errdtypeptr->true_lb == 0 && \
errsize > 0) { ferr=1; } \
} \
if (ferr) { \
err = MPIR_Err_create_code(MPI_SUCCESS, \
MPIR_ERR_RECOVERABLE, \
FCNAME, __LINE__, \
MPI_ERR_BUFFER, \
"**bufnull", 0 ); \
goto fn_fail; \
} \
}
/* The following are placeholders. We haven't decided yet whether these
should take a handle or pointer, or if they should take a handle and return
a pointer if the handle is valid. These need to be rationalized with the
MPID_xxx_valid_ptr and MPID_xxx_get_ptr.
[BRT] They should not take a handle and return a pointer if they will be
placed inside of a #ifdef HAVE_ERROR_CHECKING block. Personally, I think
the macros should take handles. We already have macros for validating
pointers to various objects.
*/
/* --BEGIN ERROR MACROS-- */
#define MPIR_ERRTEST_VALID_HANDLE(handle_,kind_,err_,errclass_,gmsg_) { \
if (HANDLE_GET_MPI_KIND(handle_) != kind_ || \
HANDLE_GET_KIND(handle_) == HANDLE_KIND_INVALID) { \
MPIR_ERR_SETANDSTMT(err_,errclass_,goto fn_fail,gmsg_); \
} \
}
/* --END ERROR MACROS-- */
#define MPIR_ERRTEST_OP(op,err) \
do { \
if (op == MPI_OP_NULL) { \
MPIR_ERR_SETANDSTMT(err,MPI_ERR_OP,goto fn_fail,"**opnull"); \
} \
else if (op == MPI_NO_OP || op == MPI_REPLACE) { \
MPIR_ERR_SETANDSTMT(err,MPI_ERR_OP,goto fn_fail,"**opnotallowed"); \
} \
else { \
MPIR_ERRTEST_VALID_HANDLE(op,MPID_OP,err,MPI_ERR_OP,"**op"); \
} \
} while (0)
#define MPIR_ERRTEST_OP_ACC(op,err) \
do { \
if (op == MPI_OP_NULL) { \
MPIR_ERR_SETANDSTMT(err,MPI_ERR_OP,goto fn_fail,"**opnull"); \
} \
else if (op == MPI_NO_OP) { \
MPIR_ERR_SETANDSTMT(err,MPI_ERR_OP,goto fn_fail,"**opnotallowed"); \
} \
else { \
MPIR_ERRTEST_VALID_HANDLE(op,MPID_OP,err,MPI_ERR_OP,"**op"); \
} \
if (HANDLE_GET_KIND(op) != HANDLE_KIND_BUILTIN) { \
MPIR_ERR_SETANDSTMT(err,MPI_ERR_OP,goto fn_fail,"**opnotpredefined"); \
} \
} while (0)
#define MPIR_ERRTEST_OP_GACC(op,err) \
do { \
if (op == MPI_OP_NULL) { \
MPIR_ERR_SETANDSTMT(err,MPI_ERR_OP,goto fn_fail,"**opnull"); \
} \
else { \
MPIR_ERRTEST_VALID_HANDLE(op,MPID_OP,err,MPI_ERR_OP,"**op"); \
} \
if (HANDLE_GET_KIND(op) != HANDLE_KIND_BUILTIN) { \
MPIR_ERR_SETANDSTMT(err,MPI_ERR_OP,goto fn_fail,"**opnotpredefined"); \
} \
} while (0)
#define MPIR_ERRTEST_GROUP(group,err) \
if (group == MPI_GROUP_NULL) { \
MPIR_ERR_SETANDSTMT(err,MPI_ERR_GROUP,goto fn_fail,"**groupnull"); \
} \
else { \
MPIR_ERRTEST_VALID_HANDLE(group,MPID_GROUP,err,MPI_ERR_GROUP,"**group"); \
}
#define MPIR_ERRTEST_COMM(comm_, err_) \
{ \
if ((comm_) == MPI_COMM_NULL) \
{ \
MPIR_ERR_SETANDSTMT((err_), MPI_ERR_COMM,goto fn_fail,"**commnull"); \
} \
else \
{ \
MPIR_ERRTEST_VALID_HANDLE((comm_), MPID_COMM, (err_), MPI_ERR_COMM, "**comm"); \
} \
}
#define MPIR_ERRTEST_WIN(win_, err_) \
{ \
if ((win_) == MPI_WIN_NULL) \
{ \
MPIR_ERR_SETANDSTMT((err_), MPI_ERR_WIN,goto fn_fail, "**winnull"); \
} \
else \
{ \
MPIR_ERRTEST_VALID_HANDLE((win_), MPID_WIN, (err_), MPI_ERR_WIN, "**win"); \
} \
}
#define MPIR_ERRTEST_REQUEST(request_, err_) \
{ \
if ((request_) == MPI_REQUEST_NULL) \
{ \
MPIR_ERR_SETANDSTMT((err_), MPI_ERR_REQUEST,goto fn_fail, "**requestnull"); \
} \
else \
{ \
MPIR_ERRTEST_VALID_HANDLE((request_), MPID_REQUEST, (err_), MPI_ERR_REQUEST, "**request"); \
} \
}
#define MPIR_ERRTEST_REQUEST_OR_NULL(request_, err_) \
{ \
if ((request_) != MPI_REQUEST_NULL) \
{ \
MPIR_ERRTEST_VALID_HANDLE((request_), MPID_REQUEST, (err_), MPI_ERR_REQUEST, "**request"); \
} \
}
/* This macro does *NOT* jump to fn_fail - all uses check mpi_errno */
#define MPIR_ERRTEST_ARRAYREQUEST_OR_NULL(request_, i_, err_) \
{ \
if ((request_) != MPI_REQUEST_NULL) \
{ \
if (HANDLE_GET_MPI_KIND(request_) != MPID_REQUEST) { \
MPIR_ERR_SETANDSTMT2(err_,MPI_ERR_REQUEST,goto fn_fail, \
"**request_invalid_kind","**request_invalid_kind %d %d", \
i_, HANDLE_GET_MPI_KIND(request_)); \
} \
else if (HANDLE_GET_KIND(request_) == HANDLE_KIND_INVALID) { \
MPIR_ERR_SETANDSTMT1(err_,MPI_ERR_REQUEST,goto fn_fail, \
"**request","**request %d", i_ ); \
} \
} \
}
#define MPIR_ERRTEST_ERRHANDLER(errhandler_,err_) \
if (errhandler_ == MPI_ERRHANDLER_NULL) { \
MPIR_ERR_SETANDSTMT(err_,MPI_ERR_ARG,goto fn_fail,"**errhandlernull"); \
} \
else { \
MPIR_ERRTEST_VALID_HANDLE(errhandler_,MPID_ERRHANDLER, \
err_,MPI_ERR_ARG,"**errhandler"); \
}
#define MPIR_ERRTEST_INFO(info_, err_) \
{ \
if ((info_) == MPI_INFO_NULL) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_ERR_ARG,goto fn_fail, "**infonull"); \
} \
else \
{ \
MPIR_ERRTEST_VALID_HANDLE((info_), MPID_INFO, (err_), MPI_ERR_ARG, "**info"); \
} \
}
#define MPIR_ERRTEST_INFO_OR_NULL(info_, err_) \
{ \
if ((info_) != MPI_INFO_NULL) \
{ \
MPIR_ERRTEST_VALID_HANDLE((info_), MPID_INFO, (err_), MPI_ERR_ARG, "**info"); \
} \
}
#define MPIR_ERRTEST_KEYVAL(keyval_, object_, objectdesc_, err_) \
{ \
if ((keyval_) == MPI_KEYVAL_INVALID) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_ERR_KEYVAL,goto fn_fail, "**keyvalinvalid"); \
} \
else if (HANDLE_GET_MPI_KIND(keyval_) != MPID_KEYVAL) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_ERR_KEYVAL,goto fn_fail, "**keyval"); \
} \
else if ((((keyval_) & 0x03c00000) >> 22) != (object_)) \
{ \
MPIR_ERR_SETANDSTMT1(err_, MPI_ERR_KEYVAL,goto fn_fail, "**keyvalobj", \
"**keyvalobj %s", (objectdesc_)); \
} \
}
#define MPIR_ERRTEST_KEYVAL_PERM(keyval_, err_) \
{ \
if (HANDLE_GET_MPI_KIND(keyval_) == MPID_KEYVAL && \
HANDLE_GET_KIND(keyval_) == HANDLE_KIND_BUILTIN) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_ERR_KEYVAL,goto fn_fail, "**permattr"); \
} \
}
#ifdef HAVE_ERROR_CHECKING
#define MPIR_ERRTEST_MPIT_INITIALIZED(err_) \
do { \
if (!MPIR_T_is_initialized()) { \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_NOT_INITIALIZED, goto fn_fail, "**mpitinit"); \
} \
} while (0)
#else
#define MPIR_ERRTEST_MPIT_INITIALIZED(err_)
#endif
#define MPIR_ERRTEST_CAT_INDEX(index_,err_) \
do { \
if ((index_) < 0 || (index_) >= utarray_len(cat_table)) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_INDEX, goto fn_fail, "**catindex"); \
} \
} while (0)
#define MPIR_ERRTEST_ENUM_HANDLE(handle_, err_) \
do { \
if ((handle_) == MPI_T_ENUM_NULL) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_HANDLE, goto fn_fail, "**enumhandlenull"); \
} \
else if ((handle_)->kind != MPIR_T_ENUM_HANDLE) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_HANDLE, goto fn_fail, "**enumhandle"); \
} \
} while (0)
#define MPIR_ERRTEST_ENUM_ITEM(enum_, index_, err_) \
do { \
if ((index_) < 0 || (index_) >= utarray_len((enum_)->items)) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_ITEM, goto fn_fail, "**itemindex"); \
} \
} while (0)
#define MPIR_ERRTEST_CVAR_INDEX(index_,err_) \
do { \
if ((index_) < 0 || (index_) >= utarray_len(cvar_table)) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_INDEX, goto fn_fail, "**cvarindex"); \
} \
} while (0)
#define MPIR_ERRTEST_CVAR_HANDLE(handle_, err_) \
do { \
if ((handle_) == MPI_T_CVAR_HANDLE_NULL) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_HANDLE, goto fn_fail, "**cvarhandlenull"); \
} \
else if ((handle_)->kind != MPIR_T_CVAR_HANDLE) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_HANDLE, goto fn_fail, "**cvarhandle"); \
} \
} while (0)
#define MPIR_ERRTEST_PVAR_INDEX(index_,err_) \
do { \
if ((index_) < 0 || (index_) >= utarray_len(pvar_table)) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_INDEX, goto fn_fail, "**pvarindex"); \
} \
} while (0)
#define MPIR_ERRTEST_PVAR_HANDLE(handle_, err_) \
do { \
if (handle_ == MPI_T_PVAR_HANDLE_NULL) \
{ \
MPIR_ERR_SETANDSTMT(err_,MPI_T_ERR_INVALID_HANDLE, goto fn_fail,"**pvarhandlenull"); \
} \
else if ((handle_)->kind != MPIR_T_PVAR_HANDLE) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_HANDLE, goto fn_fail, "**pvarhandle"); \
} \
} while (0)
#define MPIR_ERRTEST_PVAR_SESSION(session_,err_) \
do { \
if ((session_) == MPI_T_PVAR_SESSION_NULL) \
{ \
MPIR_ERR_SETANDSTMT(err_,MPI_T_ERR_INVALID_SESSION, goto fn_fail,"**pvarsessionnull"); \
} \
else if ((session_)->kind != MPIR_T_PVAR_SESSION) \
{ \
MPIR_ERR_SETANDSTMT(err_, MPI_T_ERR_INVALID_SESSION, goto fn_fail, "**pvarsession"); \
} \
} while (0)
/* some simple memcpy aliasing checks */
#define MPIR_ERR_CHKMEMCPYANDSTMT(err_,stmt_,src_,dst_,len_) \
MPIR_ERR_CHKANDSTMT3(MPIU_MEM_RANGES_OVERLAP((dst_),(len_),(src_),(len_)),err_,MPI_ERR_INTERN,stmt_,"**memcpyalias","**memcpyalias %p %p %L",(src_),(dst_),(long long)(len_))
#define MPIR_ERR_CHKMEMCPYANDJUMP(err_,src_,dst_,len_) \
MPIR_ERR_CHKMEMCPYANDSTMT((err_),goto fn_fail,(src_),(dst_),(len_))
/* Special MPI error "class/code" for out of memory */
/* FIXME: not yet done */
#define MPIR_ERR_MEMALLOCFAILED MPI_ERR_INTERN
/*
* Standardized error setting and checking macros
* These are intended to simplify the insertion of standardized error
* checks
*
*/
/* --BEGIN ERROR MACROS-- */
#ifdef HAVE_ERROR_CHECKING
#define MPIR_ERR_POP(err_) \
MPIR_ERR_SETANDSTMT(err_,MPI_ERR_OTHER,goto fn_fail,"**fail")
#define MPIR_ERR_POP_LABEL(err_, label_) \
MPIR_ERR_SETANDSTMT(err_,MPI_ERR_OTHER,goto label_,"**fail")
#define MPIR_ERR_POPFATAL(err_) \
MPIR_ERR_SETFATALANDSTMT(err_,MPI_ERR_OTHER,goto fn_fail,"**fail")
#define MPIR_ERR_POPFATAL_LABEL(err_, label_) \
MPIR_ERR_SETFATALANDSTMT(err_,MPI_ERR_OTHER,goto label_,"**fail")
#else
#define MPIR_ERR_POP(err_) goto fn_fail
#define MPIR_ERR_POP_LABEL(err_, label_) goto label_
#define MPIR_ERR_POPFATAL(err_) goto fn_fail
#define MPIR_ERR_POPFATAL_LABEL(err_, label_) goto label_
#endif
/* If you add any macros to this list, make sure that you update
maint/extracterrmsgs to handle the additional macros (see the hash
KnownErrRoutines in that script)
ERR_SETSIMPLE is like ERR_SET except that it just sets the error, it
doesn't add it to an existing error. This is appropriate in cases
where there can be no pre-existing error, and MPI_SUCCESS is needed for the
first argument to MPIR_Err_create_code .
*/
#ifdef HAVE_ERROR_CHECKING
#define MPIR_ERR_SETSIMPLE(err_,class_,msg_) \
err_ = MPIR_Err_create_code( MPI_SUCCESS,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, msg_, 0 )
#define MPIR_ERR_SET(err_,class_,msg_) \
err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, msg_, 0 )
#define MPIR_ERR_SET1(err_,class_,gmsg_,smsg_,arg1_) \
err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_ )
#define MPIR_ERR_SET2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \
err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_, arg2_ )
#define MPIR_ERR_SETANDSTMT(err_,class_,stmt_,msg_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, msg_, 0 ); stmt_ ;} while (0)
#define MPIR_ERR_SETANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_ ); stmt_ ;} while (0)
#define MPIR_ERR_SETANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_, arg2_ ); stmt_ ;} while (0)
#define MPIR_ERR_SETANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_, arg3_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_, arg2_, arg3_ ); stmt_ ;} while (0)
#define MPIR_ERR_SETANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_, arg3_, arg4_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_, arg2_, arg3_, arg4_ ); stmt_ ;} while (0)
#define MPIR_ERR_SETFATALSIMPLE(err_,class_,msg_) \
err_ = MPIR_Err_create_code( MPI_SUCCESS,MPIR_ERR_FATAL,FCNAME, \
__LINE__, class_, msg_, 0 )
#define MPIR_ERR_SETFATAL(err_,class_,msg_) \
err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\
__LINE__, class_, msg_, 0 )
#define MPIR_ERR_SETFATAL1(err_,class_,gmsg_,smsg_,arg1_) \
err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_ )
#define MPIR_ERR_SETFATAL2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \
err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_, arg2_ )
#define MPIR_ERR_SETFATALANDSTMT(err_,class_,stmt_,msg_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\
__LINE__, class_, msg_, 0 ); stmt_ ;} while (0)
#define MPIR_ERR_SETFATALANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_ ); stmt_ ;} while (0)
#define MPIR_ERR_SETFATALANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_, arg2_ ); stmt_ ;} while (0)
#define MPIR_ERR_SETFATALANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_, arg3_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_, arg2_, arg3_ ); stmt_ ;} while (0)
#define MPIR_ERR_SETFATALANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_, arg3_, arg4_) \
do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\
__LINE__, class_, gmsg_, smsg_, arg1_, arg2_, arg3_, arg4_ ); stmt_ ;} while (0)
#define MPIR_ERR_ADD(err_, newerr_) \
do {(err_) = MPIR_Err_combine_codes((err_), (newerr_));} while (0)
#else
/* Simply set the class, being careful not to override a previously
set class. */
#define MPIR_ERR_SETSIMPLE(err_,class_,msg_) \
do {err_ = class_;} while (0)
#define MPIR_ERR_SET(err_,class_,msg_) \
do {if (!err_){err_=class_;}} while (0)
#define MPIR_ERR_SET1(err_,class_,gmsg_,smsg_,arg1_) \
MPIR_ERR_SET(err_,class_,msg_)
#define MPIR_ERR_SET2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \
MPIR_ERR_SET(err_,class_,msg_)
#define MPIR_ERR_SETANDSTMT(err_,class_,stmt_,msg_) \
do {if (!err_){err_=class_;} stmt_;} while (0)
#define MPIR_ERR_SETANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_)
#define MPIR_ERR_SETANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_)
#define MPIR_ERR_SETANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_)
#define MPIR_ERR_SETANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_)
#define MPIR_ERR_SETFATALSIMPLE(err_,class_,msg_) \
do {err_ = class_;} while (0)
#define MPIR_ERR_SETFATAL(err_,class_,msg_) \
do {if (!err_){err_=class_;}} while (0)
#define MPIR_ERR_SETFATAL1(err_,class_,gmsg_,smsg_,arg1_) \
MPIR_ERR_SET(err_,class_,msg_)
#define MPIR_ERR_SETFATAL2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \
MPIR_ERR_SET(err_,class_,msg_)
#define MPIR_ERR_SETFATALANDSTMT(err_,class_,stmt_,msg_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,msg_)
#define MPIR_ERR_SETFATALANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_)
#define MPIR_ERR_SETFATALANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_)
#define MPIR_ERR_SETFATALANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_)
#define MPIR_ERR_SETFATALANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \
MPIR_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_)
/* No-op - use original error class; discard newerr_ unless err is
MPI_SUCCESS*/
#define MPIR_ERR_ADD(err_, newerr_) \
do {if (!err_) err_ = newerr_;} while (0)
#endif
/* The following definitions are the same independent of the choice of
HAVE_ERROR_CHECKING */
#define MPIR_ERR_SETANDJUMP(err_,class_,msg_) \
MPIR_ERR_SETANDSTMT(err_,class_,goto fn_fail,msg_)
#define MPIR_ERR_SETFATALANDJUMP(err_,class_,msg_) \
MPIR_ERR_SETFATALANDSTMT(err_,class_,goto fn_fail,msg_)
#define MPIR_ERR_CHKANDSTMT(cond_,err_,class_,stmt_,msg_) \
do {if (cond_) { MPIR_ERR_SETANDSTMT(err_,class_,stmt_,msg_); }} while (0)
#define MPIR_ERR_CHKFATALANDSTMT(cond_,err_,class_,stmt_,msg_) \
do {if (cond_) { MPIR_ERR_SETFATALANDSTMT(err_,class_,stmt_,msg_); }} while (0)
#define MPIR_ERR_CHKANDJUMP(cond_,err_,class_,msg_) \
MPIR_ERR_CHKANDSTMT(cond_,err_,class_,goto fn_fail,msg_)
#define MPIR_ERR_CHKFATALANDJUMP(cond_,err_,class_,msg_) \
MPIR_ERR_CHKFATALANDSTMT(cond_,err_,class_,goto fn_fail,msg_)
#define MPIR_ERR_SETANDJUMP1(err_,class_,gmsg_,smsg_,arg1_) \
MPIR_ERR_SETANDSTMT1(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_)
#define MPIR_ERR_SETFATALANDJUMP1(err_,class_,gmsg_,smsg_,arg1_) \
MPIR_ERR_SETFATALANDSTMT1(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_)
#define MPIR_ERR_CHKANDSTMT1(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_) \
do {if (cond_) { MPIR_ERR_SETANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_); }} while (0)
#define MPIR_ERR_CHKFATALANDSTMT1(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_) \
do {if (cond_) { MPIR_ERR_SETFATALANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_); }} while (0)
#define MPIR_ERR_CHKANDJUMP1(cond_,err_,class_,gmsg_,smsg_,arg1_) \
MPIR_ERR_CHKANDSTMT1(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_)
#define MPIR_ERR_CHKFATALANDJUMP1(cond_,err_,class_,gmsg_,smsg_,arg1_) \
MPIR_ERR_CHKFATALANDSTMT1(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_)
#define MPIR_ERR_SETANDJUMP2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \
MPIR_ERR_SETANDSTMT2(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_)
#define MPIR_ERR_SETFATALANDJUMP2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \
MPIR_ERR_SETFATALANDSTMT2(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_)
#define MPIR_ERR_CHKANDSTMT2(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \
do {if (cond_) { MPIR_ERR_SETANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_); }} while (0)
#define MPIR_ERR_CHKFATALANDSTMT2(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \
do {if (cond_) { MPIR_ERR_SETFATALANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_); }} while (0)
#define MPIR_ERR_CHKANDJUMP2(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_) \
MPIR_ERR_CHKANDSTMT2(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_)
#define MPIR_ERR_CHKFATALANDJUMP2(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_) \
MPIR_ERR_CHKFATALANDSTMT2(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_)
#define MPIR_ERR_SETANDJUMP3(err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_) \
MPIR_ERR_SETANDSTMT3(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_)
#define MPIR_ERR_SETFATALANDJUMP3(err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_) \
MPIR_ERR_SETFATALANDSTMT3(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_)
#define MPIR_ERR_CHKANDSTMT3(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_) \
do {if (cond_) { MPIR_ERR_SETANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_); }} while (0)
#define MPIR_ERR_CHKFATALANDSTMT3(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_) \
do {if (cond_) { MPIR_ERR_SETFATALANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_); }} while (0)
#define MPIR_ERR_CHKANDJUMP3(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_) \
MPIR_ERR_CHKANDSTMT3(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_)
#define MPIR_ERR_CHKFATALANDJUMP3(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_) \
MPIR_ERR_CHKFATALANDSTMT3(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_)
#define MPIR_ERR_SETANDJUMP4(err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \
MPIR_ERR_SETANDSTMT4(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_)
#define MPIR_ERR_SETFATALANDJUMP4(err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \
MPIR_ERR_SETFATALANDSTMT4(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_)
#define MPIR_ERR_CHKANDSTMT4(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_, arg4_) \
do {if (cond_) { MPIR_ERR_SETANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_); }} while (0)
#define MPIR_ERR_CHKFATALANDSTMT4(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_, arg4_) \
do {if (cond_) { MPIR_ERR_SETFATALANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_); }} while (0)
#define MPIR_ERR_CHKANDJUMP4(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \
MPIR_ERR_CHKANDSTMT4(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_)
#define MPIR_ERR_CHKFATALANDJUMP4(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \
MPIR_ERR_CHKFATALANDSTMT4(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_)
#define MPIR_ERR_INTERNAL(err_, msg_) \
MPIR_ERR_SETFATAL1(err_, MPI_ERR_INTERN, "**intern", "**intern %s", msg_)
#define MPIR_ERR_INTERNALANDSTMT(err_, msg_, stmt_) \
MPIR_ERR_SETANDSTMT1(err_, MPI_ERR_INTERN, stmt_, "**intern", "**intern %s", msg_)
#define MPIR_ERR_INTERNALANDJUMP(err_, msg_) \
MPIR_ERR_INTERNALANDSTMT(err_, msg_, goto fn_fail)
#define MPIR_ERR_CHKINTERNAL(cond_, err_, msg_) \
do {if (cond_) MPIR_ERR_INTERNALANDJUMP(err_, msg_);} while(0)
/* --END ERROR MACROS-- */
/*
* Special case for "is initialized".
* This should be used in cases where there is no
* additional error checking
*/
#ifdef HAVE_ERROR_CHECKING
#define MPIR_ERRTEST_INITIALIZED_ORDIE() \
do { \
if (OPA_load_int(&MPIR_Process.mpich_state) == MPICH_PRE_INIT || \
OPA_load_int(&MPIR_Process.mpich_state) == MPICH_POST_FINALIZED) \
{ \
MPIR_Err_preOrPostInit(); \
} \
} while (0)
#else
#define MPIR_ERRTEST_INITIALIZED_ORDIE() do {} while (0)
#endif
/* ------------------------------------------------------------------------- */
/* end of mpierrs.h */
/* ------------------------------------------------------------------------- */
#endif