error.hpp

 
#pragma once
 
#include <cstdlib>
#include <exception>
#include <iostream>
#include <source_location>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
 
#include <rapidsmpf/utils/misc.hpp>
 
namespace rapidsmpf {
 
struct cuda_error : public std::runtime_error {
    using std::runtime_error::runtime_error;
};
 
class bad_alloc : public std::bad_alloc {
  public:
    explicit bad_alloc(char const* msg)
        : what_{std::string{std::bad_alloc::what()} + ": " + msg} {}
 
    explicit bad_alloc(std::string const& msg) : bad_alloc{msg.c_str()} {}
 
    [[nodiscard]] char const* what() const noexcept override {
        return what_.c_str();
    }
 
  private:
    std::string what_;
};
 
class out_of_memory : public bad_alloc {
  public:
    explicit out_of_memory(char const* msg)
        : bad_alloc{std::string{"out_of_memory: "} + msg} {}
 
    explicit out_of_memory(std::string const& msg) : out_of_memory{msg.c_str()} {}
};
 
class reservation_error : public bad_alloc {
  public:
    explicit reservation_error(char const* msg)
        : bad_alloc{std::string{"reservation_error: "} + msg} {}
 
    explicit reservation_error(std::string const& msg) : reservation_error{msg.c_str()} {}
};
 
namespace detail {
 
inline std::string build_error_message(
    std::string_view reason,
    std::source_location const& loc = std::source_location::current()
) {
    std::ostringstream ss;
    ss << "RapidsMPF fatal error at: " << loc.file_name() << ":" << loc.line() << ": "
       << reason;
    return ss.str();
}
 
template <typename ThrowFn>
constexpr void expects_impl(
    bool condition,
    std::string_view reason,
    ThrowFn&& throw_fn,
    std::source_location const& loc = std::source_location::current()
) {
    if (!condition) {
        throw_fn(build_error_message(reason, loc));
    }
}
 
inline std::string build_cuda_error_message(
    cudaError_t error, std::source_location const& loc = std::source_location::current()
) {
    std::ostringstream ss;
    ss << "CUDA error at: " << loc.file_name() << ":" << loc.line() << ": "
       << cudaGetErrorName(error) << " " << cudaGetErrorString(error);
    return ss.str();
}
 
inline std::string build_cuda_alloc_error_message(
    cudaError_t error,
    std::size_t num_bytes,
    std::source_location const& loc = std::source_location::current()
) {
    std::ostringstream ss;
    ss << "CUDA error (failed to allocate " << num_bytes
       << " bytes) at: " << loc.file_name() << ":" << loc.line() << ": "
       << cudaGetErrorName(error) << " " << cudaGetErrorString(error);
    return ss.str();
}
 
[[noreturn]] inline void fatal_error(
    std::string_view reason,
    std::source_location const& loc = std::source_location::current()
) noexcept {
    std::cerr << "RapidsMPF fatal error at: " << loc.file_name() << ":" << loc.line()
              << ": " << reason << std::endl;
    std::terminate();
}
 
constexpr void expects_fatal_impl(
    bool condition,
    std::string_view reason,
    std::source_location const& loc = std::source_location::current()
) noexcept {
    if (!condition) {
        detail::fatal_error(reason, loc);
    }
}
 
[[noreturn]] inline void fatal_impl(
    std::string_view reason,
    std::source_location const& loc = std::source_location::current()
) noexcept {
    detail::fatal_error(reason, loc);
}
 
}  // namespace detail
 
#define RAPIDSMPF_EXPECTS(...)                                                         \
    GET_RAPIDSMPF_EXPECTS_MACRO(__VA_ARGS__, RAPIDSMPF_EXPECTS_3, RAPIDSMPF_EXPECTS_2) \
    (__VA_ARGS__)
 
#define GET_RAPIDSMPF_EXPECTS_MACRO(_1, _2, _3, NAME, ...) NAME
 
#define RAPIDSMPF_EXPECTS_3(_condition, _reason, _exception_type)          \
    do {                                                                   \
        static_assert(std::is_base_of_v<std::exception, _exception_type>); \
        rapidsmpf::detail::expects_impl(                                   \
            static_cast<bool>(_condition), (_reason), [](auto&& msg) {     \
                throw _exception_type{msg};                                \
            }                                                              \
        );                                                                 \
    } while (0)
 
#define RAPIDSMPF_EXPECTS_2(_condition, _reason) \
    RAPIDSMPF_EXPECTS_3(_condition, _reason, std::logic_error)
 
#define RAPIDSMPF_FAIL(...)                                                   \
    GET_RAPIDSMPF_FAIL_MACRO(__VA_ARGS__, RAPIDSMPF_FAIL_2, RAPIDSMPF_FAIL_1) \
    (__VA_ARGS__)
 
#define GET_RAPIDSMPF_FAIL_MACRO(_1, _2, NAME, ...) NAME
 
#define RAPIDSMPF_FAIL_2(_what, _exception_type)        \
    throw _exception_type {                             \
        rapidsmpf::detail::build_error_message((_what)) \
    }
 
#define RAPIDSMPF_FAIL_1(_what) RAPIDSMPF_FAIL_2(_what, std::logic_error)
 
#define RAPIDSMPF_EXPECTS_FATAL(_condition, _reason) \
    rapidsmpf::detail::expects_fatal_impl(static_cast<bool>(_condition), (_reason))
 
#define RAPIDSMPF_FATAL(_reason) rapidsmpf::detail::fatal_impl((_reason))
 
#define RAPIDSMPF_CUDA_TRY(...)                                 \
    GET_RAPIDSMPF_CUDA_TRY_MACRO(                               \
        __VA_ARGS__, RAPIDSMPF_CUDA_TRY_2, RAPIDSMPF_CUDA_TRY_1 \
    )                                                           \
    (__VA_ARGS__)
#define GET_RAPIDSMPF_CUDA_TRY_MACRO(_1, _2, NAME, ...) NAME
#define RAPIDSMPF_CUDA_TRY_2(_call, _exception_type)                                   \
    do {                                                                               \
        cudaError_t const error = (_call);                                             \
        if (cudaSuccess != error) {                                                    \
            /* Clear the CUDA error state. The error is now represented */             \
            /* by the thrown exception. */                                             \
            cudaGetLastError();                                                        \
            throw _exception_type{rapidsmpf::detail::build_cuda_error_message(error)}; \
        }                                                                              \
    } while (0)
#define RAPIDSMPF_CUDA_TRY_1(_call) RAPIDSMPF_CUDA_TRY_2(_call, rapidsmpf::cuda_error)
 
#define RAPIDSMPF_CUDA_TRY_FATAL(_call)                                     \
    do {                                                                    \
        cudaError_t const error = (_call);                                  \
        if (cudaSuccess != error) {                                         \
            std::cerr << rapidsmpf::detail::build_cuda_error_message(error) \
                      << std::endl;                                         \
            std::terminate();                                               \
        }                                                                   \
    } while (0)
 
#define RAPIDSMPF_CUDA_TRY_ALLOC(...)                                       \
    GET_RAPIDSMPF_CUDA_TRY_ALLOC_MACRO(                                     \
        __VA_ARGS__, RAPIDSMPF_CUDA_TRY_ALLOC_2, RAPIDSMPF_CUDA_TRY_ALLOC_1 \
    )                                                                       \
    (__VA_ARGS__)
#define GET_RAPIDSMPF_CUDA_TRY_ALLOC_MACRO(_1, _2, NAME, ...) NAME
 
#define RAPIDSMPF_CUDA_TRY_ALLOC_2(_call, num_bytes)                                   \
    do {                                                                               \
        cudaError_t const error = (_call);                                             \
        if (cudaSuccess != error) {                                                    \
            /* Clear the CUDA error state. The error is now represented */             \
            /* by the thrown exception. */                                             \
            cudaGetLastError();                                                        \
            auto const msg =                                                           \
                rapidsmpf::detail::build_cuda_alloc_error_message(error, (num_bytes)); \
            if (cudaErrorMemoryAllocation == error) {                                  \
                throw rapidsmpf::out_of_memory{msg};                                   \
            }                                                                          \
            throw rapidsmpf::bad_alloc{msg};                                           \
        }                                                                              \
    } while (0)
 
#define RAPIDSMPF_CUDA_TRY_ALLOC_1(_call)                                        \
    do {                                                                         \
        cudaError_t const error = (_call);                                       \
        if (cudaSuccess != error) {                                              \
            /* Clear the CUDA error state. The error is now represented */       \
            /* by the thrown exception. */                                       \
            cudaGetLastError();                                                  \
            auto const msg = rapidsmpf::detail::build_cuda_error_message(error); \
            if (cudaErrorMemoryAllocation == error) {                            \
                throw rapidsmpf::out_of_memory{msg};                             \
            }                                                                    \
            throw rapidsmpf::bad_alloc{msg};                                     \
        }                                                                        \
    } while (0)
 
}  // namespace rapidsmpf