error.hpp

 
#pragma once
 
#include <stdexcept>  // NOLINT(unused-includes)
 
#include <rapidsmpf/utils.hpp>
 
namespace rapidsmpf {
 
struct cuda_error : public std::runtime_error {
    using std::runtime_error::runtime_error;
};
 
class bad_alloc : public std::bad_alloc {
  public:
    bad_alloc(const char* msg)
        : _what{std::string{std::bad_alloc::what()} + ": " + msg} {}
 
    bad_alloc(std::string const& msg) : bad_alloc{msg.c_str()} {}
 
    [[nodiscard]] const char* what() const noexcept override {
        return _what.c_str();
    }
 
  private:
    std::string _what;
};
 
class out_of_memory : public bad_alloc {
  public:
    out_of_memory(const char* msg) : bad_alloc{std::string{"out_of_memory: "} + msg} {}
 
    out_of_memory(std::string const& msg) : out_of_memory{msg.c_str()} {}
};
 
#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>);          \
        (_condition) ? static_cast<void>(0)                                         \
                     : throw _exception_type /*NOLINT(bugprone-macro-parentheses)*/ \
            {"RAPIDSMPF failure at: " __FILE__                                      \
             ":" RAPIDSMPF_STRINGIFY(__LINE__) ": " _reason};                       \
    } 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)                                      \
    /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/                                    \
    throw _exception_type {                                                           \
        "RAPIDSMPF failure at:" __FILE__ ":" RAPIDSMPF_STRINGIFY(__LINE__) ": " _what \
    }
 
#define RAPIDSMPF_FAIL_1(_what) RAPIDSMPF_FAIL_2(_what, std::logic_error)
 
#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) {                                                    \
            cudaGetLastError();                                                        \
            /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/                             \
            throw _exception_type{                                                     \
                std::string{"CUDA error at: "} + __FILE__ + ":"                        \
                + RAPIDSMPF_STRINGIFY(__LINE__) + ": " + cudaGetErrorName(error) + " " \
                + cudaGetErrorString(error)                                            \
            };                                                                         \
        }                                                                              \
    } while (0)
#define RAPIDSMPF_CUDA_TRY_1(_call) RAPIDSMPF_CUDA_TRY_2(_call, rapidsmpf::cuda_error)
 
#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) {                                                  \
            cudaGetLastError();                                                      \
            auto const msg = std::string{"CUDA error (failed to allocate "}          \
                             + std::to_string(num_bytes) + " bytes) at: " + __FILE__ \
                             + ":" + RAPIDSMPF_STRINGIFY(__LINE__) + ": "            \
                             + cudaGetErrorName(error) + " "                         \
                             + cudaGetErrorString(error);                            \
            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) {                                          \
            cudaGetLastError();                                              \
            auto const msg = std::string{"CUDA error at: "} + __FILE__ + ":" \
                             + RAPIDSMPF_STRINGIFY(__LINE__) + ": "          \
                             + cudaGetErrorName(error) + " "                 \
                             + cudaGetErrorString(error);                    \
            if (cudaErrorMemoryAllocation == error) {                        \
                throw rapidsmpf::out_of_memory{msg};                         \
            }                                                                \
            throw rapidsmpf::bad_alloc{msg};                                 \
        }                                                                    \
    } while (0)
 
#ifdef NDEBUG
#define RAPIDSMPF_ASSERT_CUDA_SUCCESS(_call) \
    do {                                     \
        (_call);                             \
    } while (0);
#else
#define RAPIDSMPF_ASSERT_CUDA_SUCCESS(_call)                                          \
    do {                                                                              \
        cudaError_t const status__ = (_call);                                         \
        if (status__ != cudaSuccess) {                                                \
            std::cerr << "CUDA Error detected. " << cudaGetErrorName(status__) << " " \
                      << cudaGetErrorString(status__) << std::endl;                   \
        }                                                                             \
        /* NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) */     \
        assert(status__ == cudaSuccess);                                              \
    } while (0)
#endif
 
}  // namespace rapidsmpf