exceptions.hpp

Go to the documentation of this file.

/*
 *   Copyright 2025 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstdlib>
#include <cstdarg>
#include <stdexcept>
#include <string>
#include <cstdio>
#include <hicr/core/definitions.hpp>
 
namespace HiCR
{
 
namespace exceptions
{
 
enum exception_t
{
  logic,
 
  runtime,
 
  fatal
};
 
} // namespace exceptions
 
#define HICR_THROW_LOGIC(...) [[unlikely]] HiCR::throwException(HiCR::exceptions::exception_t::logic, __FILE__, __LINE__, __VA_ARGS__)
 
#define HICR_THROW_RUNTIME(...) [[unlikely]] HiCR::throwException(HiCR::exceptions::exception_t::runtime, __FILE__, __LINE__, __VA_ARGS__)
 
#define HICR_THROW_FATAL(...) [[unlikely]] HiCR::throwException(HiCR::exceptions::exception_t::fatal, __FILE__, __LINE__, __VA_ARGS__)
 
class LogicException : public std::logic_error
{
  public:
 
  __INLINE__ LogicException(const char *const message)
    : logic_error(message)
  {}
};
 
class RuntimeException : public std::runtime_error
{
  public:
 
  __INLINE__ RuntimeException(const char *const message)
    : runtime_error(message)
  {}
};
 
class FatalException : public std::runtime_error
{
  public:
 
  __INLINE__ FatalException(const char *const message)
    : runtime_error(message)
  {}
};
 
__INLINE__ static void throwException [[noreturn]] (const exceptions::exception_t type, const char *fileName, const int lineNumber, const char *format, ...)
{
  char   *outstr = nullptr;
  va_list ap;
  va_start(ap, format);
  auto res = vasprintf(&outstr, format, ap);
 
  if (res < 0)
  {
    auto errorMsg = std::string("Error in exceptions.hpp, throwLogic() function\n");
 
#ifdef HICR_EXCEPTION_USE_STDEXCEPTION
    throw std::runtime_error(errorMsg.c_str());
#endif
 
#ifdef HICR_EXCEPTION_USE_ABORT
    fprintf(stderr, "%s", errorMsg.c_str());
    fflush(stderr);
    std::abort();
#endif
  }
 
  std::string typeString = "Undefined";
  switch (type)
  {
  case exceptions::exception_t::logic: typeString = "Logic"; break;
  case exceptions::exception_t::runtime: typeString = "Runtime"; break;
  case exceptions::exception_t::fatal: typeString = "Fatal"; break;
  default: break;
  }
  std::string outString = std::string("[HiCR] ") + typeString + std::string(" Exception: ") + std::string(outstr);
  free(outstr);
 
  const size_t bufferSize = 1024;
  char         info[bufferSize];
  snprintf(info, sizeof(info) - 1, " + From %s:%d\n", fileName, lineNumber);
  outString += info;
 
#ifdef HICR_EXCEPTION_USE_STDEXCEPTION
 
  switch (type)
  {
  case exceptions::exception_t::logic: throw LogicException(outString.c_str()); break;
  case exceptions::exception_t::runtime: throw RuntimeException(outString.c_str()); break;
  case exceptions::exception_t::fatal: throw FatalException(outString.c_str()); break;
  default: break;
  }
 
  throw std::runtime_error(outString.c_str());
 
#endif
 
  // #ifdef HICR_EXCEPTION_USE_ABORT
 
  fprintf(stderr, "%s", outString.c_str());
  fflush(stderr);
  std::abort();
 
  // #endif
}
 
} // namespace HiCR