assertion.hpp

Go to the documentation of this file.

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// The following line is necessary - otherwise doxygen won't document the #define's in this file.
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/runtime.hpp>
 
// includes, system
#include <string>
 
namespace FEAT
{
  CUDA_HOST_DEVICE [[noreturn]] inline void abortion(
    const char * const func,
    const char * const file,
    const int line,
    const char * const msg)
  {
    #ifndef __CUDA_ARCH__
    // write error message if available
    if(msg != nullptr)
      fprintf(stderr, "\n>>> FATAL ERROR: %s\n\n", msg);
    else
      fprintf(stderr, "\n>>> FATAL ERROR: UNSPECIFIED ABORTION\n\n");
 
    // write basic information
    fprintf(stderr, "Function: %s\n", func);
    fprintf(stderr, "File....: %s\n", file);
    fprintf(stderr, "Line....: %i\n", line);
 
    // flush stderr
    fflush(stderr);
 
    // abort execution;
    // this may also write a call-stack dump if possible
    Runtime::abort();
    #else
    // write error message if available
    if(msg != nullptr)
      printf("\n>>> FATAL ERROR: %s\n\n", msg);
    else
      printf("\n>>> FATAL ERROR: UNSPECIFIED ABORTION\n\n");
 
    // write basic information
    printf("Function: %s\n", func);
    printf("File....: %s\n", file);
    printf("Line....: %i\n", line);
 
    // and trap the process
    __trap();
    #endif
  }
 
  CUDA_HOST [[noreturn]] inline void abortion(const char* const func, const char* const file, const int line, const std::string& msg)
  {
    abortion(func, file, line, msg.c_str());
  }
 
  CUDA_HOST_DEVICE void inline assertion(
    bool expr,
    const char * const expr_str,
    const char * const func,
    const char * const file,
    const int line,
    const char * const msg = nullptr)
  {
    // alright?
    if(expr)
      return;
    #ifndef __CUDA_ARCH__
    // write error message if available
    if(msg != nullptr)
      fprintf(stderr, "\n>>> FATAL ERROR: ASSERTION FAILED: %s\n", msg);
    else
      fprintf(stderr, "\n>>> FATAL ERROR: ASSERTION FAILED\n");
 
    // write basic information
    fprintf(stderr, "Expression: %s\n", expr_str);
    fprintf(stderr, "Function..: %s\n", func);
    fprintf(stderr, "File......: %s\n", file);
    fprintf(stderr, "Line......: %i\n", line);
 
    // flush stderr
    fflush(stderr);
 
    // abort execution;
    // this may also write a call-stack dump if possible
    Runtime::abort();
    #else
    // cuda does only know printf
    if(msg != nullptr)
      printf("\n>>> FATAL ERROR: ASSERTION FAILED: %s\n", msg);
    else
      printf("\n>>> FATAL ERROR: ASSERTION FAILED\n");
 
    // write basic information
    printf("Expression: %s\n", expr_str);
    printf("Function..: %s\n", func);
    printf("File......: %s\n", file);
    printf("Line......: %i\n", line);
 
    // also cuda should and can not abort our runtime, so we use an internal trap
    // to send an interupt signal... warning, this could (in theory) be catched and ignored
    __trap();
    #endif
  }
 
  CUDA_HOST inline void assertion(
    bool expr,
    const char* const expr_str,
    const char* const func,
    const char* const file,
    const int line,
    const std::string& msg)
  {
    assertion(expr, expr_str, func, file, line, msg.c_str());
  }
 
#if defined(FEAT_COMPILER_INTEL) && (FEAT_COMPILER_INTEL < 2000)
#  define XABORTM(msg) do {FEAT::abortion(__func__, __FILE__, __LINE__, msg); std::abort();} while(false)
#else // any smart C++ compiler
#  define XABORTM(msg) FEAT::abortion(__func__, __FILE__, __LINE__, msg)
#endif
 
 
#if defined(DEBUG)
#  define ASSERT(expr) FEAT::assertion(expr, #expr, __func__, __FILE__, __LINE__)
#  define ASSERTM(expr, msg) FEAT::assertion(expr, #expr, __func__, __FILE__, __LINE__, msg)
#else
#  define ASSERT(expr) void(0)
#  define ASSERTM(expr, msg) void(0)
#endif
 
#define XASSERT(expr) FEAT::assertion(expr, #expr, __func__, __FILE__, __LINE__)
#define XASSERTM(expr, msg) FEAT::assertion(expr, #expr, __func__, __FILE__, __LINE__, msg)
 
} // namespace FEAT