error.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <cstdlib>
#include <exception>
#include <iostream>
#include <string>
#include <sstream>
#include <iostream>
 
#ifdef NF_WITH_MPI_SUPPORT
#include <mpi.h>
#endif
 
// compiling with clang and cuda fails to
// find source location
// #include <source_location>
// #include <experimental/source_location>
 
// #include "logging.hpp"
#include "info.hpp"
 
namespace NeoN::Logging::detail
{
// Forward declaration: error.hpp must not include logging.hpp — that would form a
// cycle (logging.hpp -> mpi/environment.hpp -> error.hpp). logFatal is defined in
// core/logging.cpp; NF_ERROR_EXIT routes through it for rank-tagged output, a
// stack trace, and a clean MPI_Abort.
[[noreturn]] void logFatal(const std::string& message);
}
 
namespace NeoN
{
 
class NeoNException : public std::exception
{
public:
 
    explicit NeoNException(const std::string& message) : message_(message) {}
 
    const char* what() const noexcept override { return message_.c_str(); }
 
private:
 
    std::string message_; 
};
 
} // namespace NeoN
 
#define NF_ERROR_MESSAGE(message)                                                                  \
    "Error: " << message << "\nFile: " << __FILE__ << "\nLine: " << __LINE__ << "\n"
 
// Builds the message into a temporary stringstream (not a named local, so this
// is usable inside constexpr functions) and routes it through logFatal, which
// tags the rank, prints a trace, MPI_Aborts, and exits.
#define NF_ERROR_EXIT(message)                                                                     \
    NeoN::Logging::detail::logFatal((std::stringstream() << NF_ERROR_MESSAGE(message)).str())
 
#define NF_THROW(message)                                                                          \
    throw NeoN::NeoNException((std::stringstream() << NF_ERROR_MESSAGE(std::string(message))).str())
 
#define NF_ASSERT(condition, message)                                                              \
    do                                                                                             \
    {                                                                                              \
        if (!(condition)) [[unlikely]]                                                             \
        {                                                                                          \
            NF_ERROR_EXIT(                                                                         \
                "Assertion `" #condition " in " << __FILE__ << ":" << __LINE__                     \
                                                << "` failed.\n       " << message                 \
            );                                                                                     \
        }                                                                                          \
    }                                                                                              \
    while (false)
 
#define NF_ASSERT_THROW(condition, message)                                                        \
    do                                                                                             \
    {                                                                                              \
        if (!(condition)) [[unlikely]]                                                             \
        {                                                                                          \
            NF_THROW("Assertion `" #condition "` failed.\n       " << message);                    \
        }                                                                                          \
    }                                                                                              \
    while (false)
 
#ifdef NF_DEBUG
#define NF_DEBUG_ASSERT(condition, message) NF_ASSERT(condition, message)
 
#define NF_DEBUG_ASSERT_THROW(condition, message) NF_ASSERT_THROW(condition, message)
#else
#define NF_DEBUG_ASSERT(condition, message) ((void)0)
 
#define NF_DEBUG_ASSERT_THROW(condition, message) ((void)0)
#endif
 
#define NF_ASSERT_EQUAL(a, b) NF_ASSERT(a == b, "Expected " << b << ", got " << a)
 
#define NF_DEBUG_ASSERT_EQUAL(a, b) NF_DEBUG_ASSERT(a == b, "Expected " << b << ", got " << a)
 
#define NF_ASSERT_EQUAL_THROW(a, b) NF_ASSERT_THROW(a == b, "Expected " << b << ", got " << a)
 
#define NF_DEBUG_ASSERT_EQUAL_THROW(a, b)                                                          \
    NF_DEBUG_ASSERT_THROW(a == b, "Expected " << b << ", got " << a)