error.h

Go to the documentation of this file.

/***************************************************************************
// Adapted from the GNU Scientific Library
// Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough
//-----------------------------------------------------------------------bl-
// underling 0.3.1: an FFTW MPI-based library for 3D pencil decompositions
// https://github.com/RhysU/underling
//
// Copyright (C) 2010--2013, 2026 Rhys Ulerich
// Copyright (C) 2012, 2013 The PECOS Development Team
//
// This file is part of underling.
//
// underling is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// underling is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with underling.  If not, see <http://www.gnu.org/licenses/>.
//-----------------------------------------------------------------------el-
// $Id$
***************************************************************************/
 
#ifndef UNDERLING_ERROR_H
#define UNDERLING_ERROR_H
 
#include <stdio.h>
#include <underling/visibility.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum underling_status {
    UNDERLING_SUCCESS  =  0, 
    UNDERLING_EFAULT   =  3, 
    UNDERLING_EINVAL   =  4, 
    UNDERLING_EFAILED  =  5, 
    UNDERLING_ESANITY  =  7, 
    UNDERLING_ENOMEM   =  8  
};
 
void
underling_error(const char * reason,
                const char * file,
                int line,
                int underling_errno) UNDERLING_API;
 
void
underling_stream_printf(const char *label,
                        const char *file,
                        int line,
                        const char *reason) UNDERLING_API;
 
const char *
underling_strerror(const int underling_errno) UNDERLING_API;
 
typedef void underling_error_handler_t(const char * reason,
                                       const char * file,
                                       int line,
                                       int underling_errno);
 
typedef void underling_stream_handler_t(const char * label,
                                        const char * file,
                                        int line,
                                        const char * reason);
 
underling_error_handler_t *
underling_set_error_handler(underling_error_handler_t * new_handler)
    UNDERLING_API;
 
underling_error_handler_t *
underling_set_error_handler_off(void) UNDERLING_API;
 
underling_stream_handler_t *
underling_set_stream_handler(underling_stream_handler_t * new_handler)
    UNDERLING_API;
 
FILE *
underling_set_stream(FILE * new_stream) UNDERLING_API;
 
#define UNDERLING_ERROR(reason, underling_errno) \
       do { \
       underling_error (reason, __FILE__, __LINE__, underling_errno) ; \
       return underling_errno ; \
       } while (0)
 
#define UNDERLING_ERROR_VAL(reason, underling_errno, value) \
       do { \
       underling_error (reason, __FILE__, __LINE__, underling_errno) ; \
       return value ; \
       } while (0)
 
#define UNDERLING_ERROR_VOID(reason, underling_errno) \
       do { \
       underling_error (reason, __FILE__, __LINE__, underling_errno) ; \
       return ; \
       } while (0)
 
#define UNDERLING_ERROR_NULL(reason, underling_errno) \
        UNDERLING_ERROR_VAL(reason, underling_errno, 0)
 
#define UNDERLING_ERROR_NULL_FMT(underling_errno, fmt, ...) \
       do { \
       char _err_buf[256]; \
       snprintf(_err_buf, sizeof(_err_buf), fmt, __VA_ARGS__); \
       underling_error (_err_buf, __FILE__, __LINE__, underling_errno) ; \
       return 0 ; \
       } while (0)
 
#define UNDERLING_ERROR_REPORT(reason, underling_errno) \
       do { \
       underling_error (reason, __FILE__, __LINE__, underling_errno) ; \
       } while (0)
 
/* Internal helper macro for implementing UNDERLING_MPICHKx macros */
#define UNDERLING_MPICHKx_TEMPLATE(underling_error_macro,stmt) \
    do { \
        const int _chk_stat = (stmt); \
        if (_chk_stat != MPI_SUCCESS) { \
            char _chk_reason[MPI_MAX_ERROR_STRING + 64]; \
            char _chk_mpistring[MPI_MAX_ERROR_STRING]; \
            int _chk_len; \
            const int _chk_string_stat \
                = MPI_Error_string(_chk_stat,_chk_mpistring,&_chk_len); \
            snprintf(_chk_reason, sizeof(_chk_reason)/sizeof(_chk_reason[0]), \
                    "Encountered MPI error code %d: %s", _chk_stat, \
                    (_chk_string_stat == MPI_SUCCESS) \
                    ? _chk_mpistring : "UNKNOWN"); \
            underling_error_macro(_chk_reason, UNDERLING_EFAILED); \
        } \
    } while(0)
 
#define UNDERLING_MPICHKQ(stmt) \
    UNDERLING_MPICHKx_TEMPLATE(UNDERLING_ERROR,stmt)
 
#define UNDERLING_MPICHKN(stmt) \
    UNDERLING_MPICHKx_TEMPLATE(UNDERLING_ERROR_NULL,stmt)
 
#define UNDERLING_MPICHKV(stmt) \
    UNDERLING_MPICHKx_TEMPLATE(UNDERLING_ERROR_VOID,stmt)
 
#define UNDERLING_MPICHKR(stmt) \
    UNDERLING_MPICHKx_TEMPLATE(UNDERLING_ERROR_REPORT,stmt)
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* UNDERLING_ERROR_H__ */