error.h

Go to the documentation of this file.

#ifndef GHOST_ERROR_H
#define GHOST_ERROR_H

#ifdef __cplusplus
#include <cstring>
#else
#include <string.h>
#endif
#include "log.h"

#ifndef GHOST_HAVE_ZOLTAN
#define ZOLTAN_OK 0
#endif

typedef enum {
    GHOST_SUCCESS,
    GHOST_ERR_INVALID_ARG,
    GHOST_ERR_MPI,
    GHOST_ERR_CUDA,
    GHOST_ERR_CUBLAS,
    GHOST_ERR_CUSPARSE,
    GHOST_ERR_CURAND,
    GHOST_ERR_HWLOC,
    GHOST_ERR_SCOTCH,
    GHOST_ERR_ZOLTAN,
    GHOST_ERR_UNKNOWN,
    GHOST_ERR_NOT_IMPLEMENTED,
    GHOST_ERR_IO,
    GHOST_ERR_DATATYPE,
    GHOST_ERR_COLPACK,
    GHOST_ERR_BLOCKCOLOR,
    GHOST_ERR_NOT_COLORED,
    GHOST_ERR_RED_BLACK,
    GHOST_ERR_LAPACK,
    GHOST_ERR_BLAS,
    GHOST_ERR_COMPATIBILITY 
} ghost_error;

#include "errorhandler.h"

#define GHOST_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    GHOST_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\


#define GHOST_CALL_GOTO(call,label,__err) {\
    GHOST_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\


#define GHOST_CALL(call,__err) {\
    __err = call;\
    if (__err != GHOST_SUCCESS) {\
        GHOST_LOG(GHOST_ERROR,GHOST_ANSI_COLOR_RED,"%s",ghost_error_string((ghost_error)__err));\
    }\
}\

#define MPI_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    MPI_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define MPI_CALL_GOTO(call,label,__err) {\
    MPI_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define MPI_CALL(call,__err) {\
    int mpicallmacroerr = call;\
    if (mpicallmacroerr != MPI_SUCCESS) {\
        char errstr[MPI_MAX_ERROR_STRING];\
        int strlen;\
        MPI_Error_string(mpicallmacroerr,errstr,&strlen);\
        GHOST_ERROR_LOG("MPI Error: %s",errstr);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_MPI);\
        if (h) {\
            h((void *)&mpicallmacroerr);\
        }\
        __err = GHOST_ERR_MPI;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define HWLOC_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    HWLOC_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define HWLOC_CALL_GOTO(call,label,__err) {\
    HWLOC_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define HWLOC_CALL(call,__err) {\
    int __hwlocerr = call;\
    if (__hwlocerr) {\
        GHOST_ERROR_LOG("HWLOC Error: %d",__hwlocerr);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_HWLOC);\
        if (h) {\
            h((void *)&__hwlocerr);\
        }\
        __err = GHOST_ERR_HWLOC;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define CUDA_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    CUDA_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define CUDA_CALL_GOTO(call,label,__err) {\
    CUDA_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define CUDA_CALL(call,__err) {\
    cudaError_t __cuerr = call;\
    if (__cuerr != cudaSuccess) {\
        GHOST_ERROR_LOG("CUDA Error: %s (%d)",cudaGetErrorString(__cuerr),(int)__cuerr);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_CUDA);\
        if (h) {\
            h((void *)&__cuerr);\
        }\
        __err = GHOST_ERR_CUDA;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define CUBLAS_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    CUBLAS_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define CUBLAS_CALL_GOTO(call,label,__err) {\
    CUBLAS_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define CUBLAS_CALL(call,__err) {\
    cublasStatus_t err = call;\
    if (err != CUBLAS_STATUS_SUCCESS) {\
        switch (err) {\
            case CUBLAS_STATUS_NOT_INITIALIZED:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_NOT_INITIALIZED");\
                break;\
            case CUBLAS_STATUS_ALLOC_FAILED:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_ALLOC_FAILED");\
                break;\
            case CUBLAS_STATUS_INVALID_VALUE:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_INVALID_VALUE");\
                break;\
            case CUBLAS_STATUS_ARCH_MISMATCH:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_ARCH_MISMATCH");\
                break;\
            case CUBLAS_STATUS_MAPPING_ERROR:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_MAPPING_ERROR");\
                break;\
            case CUBLAS_STATUS_EXECUTION_FAILED:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_EXECUTION_FAILED");\
                break;\
            case CUBLAS_STATUS_INTERNAL_ERROR:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_INTERNAL_ERROR");\
                break;\
            case CUBLAS_STATUS_NOT_SUPPORTED:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_NOT_SUPPORTED");\
                break;\
            case CUBLAS_STATUS_LICENSE_ERROR:\
                GHOST_ERROR_LOG("CUBLAS error: CUBLAS_STATUS_LICENSE_ERROR");\
                break;\
            default:\
                GHOST_ERROR_LOG("CUBLAS error: Unknown CUBLAS error");\
                break;\
        }\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_CUBLAS);\
        if (h) {\
            h((void *)&err);\
        }\
        __err = GHOST_ERR_CUBLAS;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define CURAND_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    CURAND_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define CURAND_CALL_GOTO(call,label,__err) {\
    CURAND_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define CURAND_CALL(call,__err) {\
    curandStatus_t err = call;\
    if (err != CURAND_STATUS_SUCCESS) {\
        GHOST_ERROR_LOG("CURAND Error: %d",(int)err);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_CURAND);\
        if (h) {\
            h((void *)&err);\
        }\
        __err = GHOST_ERR_CURAND;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define CUSPARSE_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    CUSPARSE_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define CUSPARSE_CALL_GOTO(call,label,__err) {\
    CUSPARSE_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define CUSPARSE_CALL(call,__err) {\
    cusparseStatus_t err = call;\
    if (err != CUSPARSE_STATUS_SUCCESS) {\
        GHOST_ERROR_LOG("CUSPARSE Error: %d",(int)err);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_CUSPARSE);\
        if (h) {\
            h((void *)&err);\
        }\
        __err = GHOST_ERR_CUSPARSE;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define SCOTCH_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    SCOTCH_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define SCOTCH_CALL_GOTO(call,label,__err) {\
    SCOTCH_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define SCOTCH_CALL(call,__err) {\
    int err = call;\
    if (err) {\
        GHOST_ERROR_LOG("SCOTCH Error: %d",err);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_SCOTCH);\
        if (h) {\
            h((void *)&err);\
        }\
        __err = GHOST_ERR_SCOTCH;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define COLPACK_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    COLPACK_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define COLPACK_CALL_GOTO(call,label,__err) {\
    COLPACK_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define COLPACK_CALL(call,__err) {\
    int err = call;\
    if (err != _TRUE) {\
        GHOST_ERROR_LOG("ColPack Error: %d",err);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_COLPACK);\
        if (h) {\
            h((void *)&err);\
        }\
        __err = GHOST_ERR_COLPACK;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define ZOLTAN_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    ZOLTAN_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define ZOLTAN_CALL_GOTO(call,label,__err) {\
    ZOLTAN_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define ZOLTAN_CALL(call,__err) {\
    int err = call;\
    if (err != ZOLTAN_OK) {\
        GHOST_ERROR_LOG("Zoltan Error: %d",err);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_ZOLTAN);\
        if (h) {\
            h((void *)&err);\
        }\
        __err = GHOST_ERR_ZOLTAN;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#define BLAS_CALL_RETURN(call) {\
    ghost_error macroerr = GHOST_SUCCESS;\
    BLAS_CALL(call,macroerr);\
    if (macroerr != GHOST_SUCCESS) {\
        return macroerr;\
    }\
}\

#define BLAS_CALL_GOTO(call,label,__err) {\
    BLAS_CALL(call,__err);\
    if (__err != GHOST_SUCCESS) {\
        goto label;\
    }\
}\

#define BLAS_CALL(call,__err) {\
    call;\
    int err = ghost_blas_err_pop();\
    if (err) {\
        GHOST_ERROR_LOG("BLAS Error: %d",err);\
        ghost_errorhandler h = ghost_errorhandler_get(GHOST_ERR_BLAS);\
        if (h) {\
            h((void *)&err);\
        }\
        __err = GHOST_ERR_BLAS;\
    } else {\
        __err = GHOST_SUCCESS;\
    }\
}\

#ifdef __cplusplus
    extern "C" {
#endif

        char * ghost_error_string(ghost_error e);

#ifdef __cplusplus
    }
#endif

#endif