Charm++: Charm Source Code Documentation

00001 /* -*- Mode: C; c-basic-offset:4 ; -*- */
00002 /*
00003  *  (C) 2001 by Argonne National Laboratory.
00004  *      See COPYRIGHT in top-level directory.
00005  */
00006 
00007 #include <string.h> /* for strerror() */
00008 
00009 /* MPIO_CHECK_XXX macros are used to clean up error checking and
00010  * handling in many of the romio/mpi-io/ source files.
00011  */
00012 #define MPIO_CHECK_FILE_HANDLE(fh, myname, error_code)          \
00013 if ((fh <= (ADIO_File) 0) ||                    \
00014     ((fh)->cookie != ADIOI_FILE_COOKIE)) {          \
00015     error_code = MPIO_Err_create_code(MPI_SUCCESS,      \
00016                       MPIR_ERR_RECOVERABLE, \
00017                       myname, __LINE__,     \
00018                       MPI_ERR_ARG,      \
00019                       "**iobadfh", 0);      \
00020     error_code = MPIO_Err_return_file(MPI_FILE_NULL, error_code);\
00021     goto fn_exit;                                               \
00022 }
00023 
00024 #define MPIO_CHECK_COUNT(fh, count, myname, error_code)         \
00025 if (count < 0) {                        \
00026     error_code = MPIO_Err_create_code(MPI_SUCCESS,      \
00027                       MPIR_ERR_RECOVERABLE, \
00028                       myname, __LINE__,     \
00029                       MPI_ERR_ARG,      \
00030                       "**iobadcount", 0);   \
00031     error_code = MPIO_Err_return_file(fh, error_code);      \
00032     goto fn_exit;                                               \
00033 }
00034 
00035 #define MPIO_CHECK_COUNT_SIZE(fh, count, datatype_size, myname, error_code)         \
00036 if (count*datatype_size != (ADIO_Offset)(unsigned)count*(ADIO_Offset)(unsigned)datatype_size) { \
00037     error_code = MPIO_Err_create_code(MPI_SUCCESS,      \
00038                       MPIR_ERR_RECOVERABLE, \
00039                       myname, __LINE__,     \
00040                       MPI_ERR_ARG,      \
00041                       "**iobadcount", 0);   \
00042     error_code = MPIO_Err_return_file(fh, error_code);      \
00043     goto fn_exit;                                               \
00044 }
00045 
00046 #define MPIO_CHECK_DATATYPE(fh, datatype, myname, error_code)   \
00047 if (datatype == MPI_DATATYPE_NULL) {                \
00048     error_code = MPIO_Err_create_code(MPI_SUCCESS,      \
00049                       MPIR_ERR_RECOVERABLE, \
00050                       myname, __LINE__,     \
00051                       MPI_ERR_TYPE,         \
00052                       "**dtypenull", 0);    \
00053     error_code = MPIO_Err_return_file(fh, error_code);      \
00054     goto fn_exit;                                               \
00055 }
00056 
00057 #define MPIO_CHECK_READABLE(fh, myname, error_code)     \
00058 if (fh->access_mode & ADIO_WRONLY) {            \
00059     error_code = MPIO_Err_create_code(MPI_SUCCESS,      \
00060                       MPIR_ERR_RECOVERABLE, \
00061                       myname, __LINE__,     \
00062                       MPI_ERR_ACCESS,       \
00063                       "**iowronly", 0);     \
00064     error_code = MPIO_Err_return_file(fh, error_code);          \
00065     goto fn_exit;                                               \
00066 }
00067 
00068 #define MPIO_CHECK_WRITABLE(fh, myname, error_code)     \
00069 if (fh->access_mode & ADIO_RDONLY) {            \
00070     error_code = MPIO_Err_create_code(MPI_SUCCESS,      \
00071                       MPIR_ERR_RECOVERABLE, \
00072                       myname, __LINE__,     \
00073                       MPI_ERR_READ_ONLY,    \
00074                       "**iordonly",     \
00075                       0);           \
00076     error_code = MPIO_Err_return_file(fh, error_code);      \
00077     goto fn_exit;                                               \
00078 }
00079 
00080 #define MPIO_CHECK_NOT_SEQUENTIAL_MODE(fh, myname, error_code)      \
00081 if (fh->access_mode & ADIO_SEQUENTIAL) {                \
00082     error_code = MPIO_Err_create_code(MPI_SUCCESS,          \
00083                       MPIR_ERR_RECOVERABLE,     \
00084                       myname, __LINE__,         \
00085                       MPI_ERR_UNSUPPORTED_OPERATION,    \
00086                       "**ioamodeseq", 0);       \
00087     error_code = MPIO_Err_return_file(fh, error_code);                  \
00088     goto fn_exit;                                                       \
00089 }
00090 
00091 #define MPIO_CHECK_INTEGRAL_ETYPE(fh, count, dtype_size, myname, error_code) \
00092 if ((count*dtype_size) % fh->etype_size != 0) {                  \
00093     error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,     \
00094                       myname, __LINE__, MPI_ERR_IO,          \
00095                       "**ioetype", 0);               \
00096     error_code = MPIO_Err_return_file(fh, error_code);               \
00097     goto fn_exit;                                                            \
00098 }
00099 
00100 #define MPIO_CHECK_FS_SUPPORTS_SHARED(fh, myname, error_code)       \
00101 if ((fh->file_system == ADIO_PIOFS) ||                  \
00102     (fh->file_system == ADIO_PVFS) ||                   \
00103     (fh->file_system == ADIO_PVFS2))                    \
00104 {                                   \
00105     error_code = MPIO_Err_create_code(MPI_SUCCESS,          \
00106                       MPIR_ERR_RECOVERABLE,     \
00107                       myname, __LINE__,         \
00108                       MPI_ERR_UNSUPPORTED_OPERATION,    \
00109                       "**iosharedunsupported", 0);  \
00110     error_code = MPIO_Err_return_file(fh, error_code);          \
00111     goto fn_exit;                                                       \
00112 }
00113 
00114 /* MPIO_ERR_CREATE_CODE_XXX macros are used to clean up creation of
00115  * error codes for common cases in romio/adio/
00116  */
00117 #define MPIO_ERR_CREATE_CODE_ERRNO(myname, myerrno, error_code_p) \
00118 *(error_code_p) = MPIO_Err_create_code(MPI_SUCCESS,       \
00119                        MPIR_ERR_RECOVERABLE,      \
00120                        myname, __LINE__,      \
00121                        MPI_ERR_IO,        \
00122                        "System call I/O error",   \
00123                        "Syscall error from %s: %s",   \
00124                        myname,                    \
00125                        strerror(myerrno));
00126 
00127 #define MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, key, error_code_p)         \
00128 *(error_code_p) = MPIO_Err_create_code(MPI_SUCCESS,               \
00129                        MPIR_ERR_RECOVERABLE,              \
00130                        myname, __LINE__,              \
00131                                        MPI_ERR_NOT_SAME,                      \
00132                        "Value for info key not same across processes",  \
00133                        "Value for info key %s not same across processes",\
00134                        key);
00135 
00136 
00137 /* TODO: handle the independent io case more gracefully  */
00138 #define ADIOI_TEST_DEFERRED(fh, myname, error_code)\
00139     if(! (fh)->is_open ) {\
00140         ADIO_ImmediateOpen((fh), (error_code)); }
libs/ck-libs/ampi/romio/adio/include/adioi_error.h
