detail/error.hpp

/*
 * SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <rmm/error.hpp>
 
#include <cuda_runtime_api.h>
 
#include <cassert>
#include <exception>
#include <iostream>
#include <string>
#include <type_traits>
 
#define STRINGIFY_DETAIL(x) #x
#define RMM_STRINGIFY(x)    STRINGIFY_DETAIL(x)

#define RMM_EXPECTS(...)                                           \
  GET_RMM_EXPECTS_MACRO(__VA_ARGS__, RMM_EXPECTS_3, RMM_EXPECTS_2) \
  (__VA_ARGS__)
#define GET_RMM_EXPECTS_MACRO(_1, _2, _3, NAME, ...) NAME
#define RMM_EXPECTS_3(_condition, _reason, _exception_type)                                     \
  do {                                                                                          \
    static_assert(std::is_base_of_v<std::exception, _exception_type>);                          \
    /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/                                              \
    (!!(_condition)) ? static_cast<void>(0)                                                     \
                     : throw _exception_type{std::string{"RMM failure at: "} + __FILE__ + ":" + \
                                             RMM_STRINGIFY(__LINE__) + ": " + _reason};         \
  } while (0)
#define RMM_EXPECTS_2(_condition, _reason) RMM_EXPECTS_3(_condition, _reason, rmm::logic_error)

#define RMM_FAIL(...)                                     \
  GET_RMM_FAIL_MACRO(__VA_ARGS__, RMM_FAIL_2, RMM_FAIL_1) \
  (__VA_ARGS__)
#define GET_RMM_FAIL_MACRO(_1, _2, NAME, ...) NAME
#define RMM_FAIL_2(_what, _exception_type)                                                   \
  /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/                                             \
  throw _exception_type                                                                      \
  {                                                                                          \
    std::string{"RMM failure at:"} + __FILE__ + ":" + RMM_STRINGIFY(__LINE__) + ": " + _what \
  }
#define RMM_FAIL_1(_what) RMM_FAIL_2(_what, rmm::logic_error)

#define RMM_CUDA_TRY(...)                                             \
  GET_RMM_CUDA_TRY_MACRO(__VA_ARGS__, RMM_CUDA_TRY_2, RMM_CUDA_TRY_1) \
  (__VA_ARGS__)
#define GET_RMM_CUDA_TRY_MACRO(_1, _2, NAME, ...) NAME
#define RMM_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__ + ":" +                \
                            RMM_STRINGIFY(__LINE__) + ": " + cudaGetErrorName(error) + " " + \
                            cudaGetErrorString(error)};                                      \
    }                                                                                        \
  } while (0)
#define RMM_CUDA_TRY_1(_call) RMM_CUDA_TRY_2(_call, rmm::cuda_error)

#define RMM_CUDA_TRY_ALLOC(...)                                                         \
  GET_RMM_CUDA_TRY_ALLOC_MACRO(__VA_ARGS__, RMM_CUDA_TRY_ALLOC_2, RMM_CUDA_TRY_ALLOC_1) \
  (__VA_ARGS__)
#define GET_RMM_CUDA_TRY_ALLOC_MACRO(_1, _2, NAME, ...) NAME
 
#define RMM_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__ + ":" +    \
                       RMM_STRINGIFY(__LINE__) + ": " + cudaGetErrorName(error) + " " + \
                       cudaGetErrorString(error);                                       \
      if (cudaErrorMemoryAllocation == error) { throw rmm::out_of_memory{msg}; }        \
      throw rmm::bad_alloc{msg};                                                        \
    }                                                                                   \
  } while (0)
 
#define RMM_CUDA_TRY_ALLOC_1(_call)                                                                \
  do {                                                                                             \
    cudaError_t const error = (_call);                                                             \
    if (cudaSuccess != error) {                                                                    \
      cudaGetLastError();                                                                          \
      auto const msg = std::string{"CUDA error at: "} + __FILE__ + ":" + RMM_STRINGIFY(__LINE__) + \
                       ": " + cudaGetErrorName(error) + " " + cudaGetErrorString(error);           \
      if (cudaErrorMemoryAllocation == error) { throw rmm::out_of_memory{msg}; }                   \
      throw rmm::bad_alloc{msg};                                                                   \
    }                                                                                              \
  } while (0)

#ifdef NDEBUG
#define RMM_ASSERT_CUDA_SUCCESS(_call) \
  do {                                 \
    (_call);                           \
  } while (0);
#else
#define RMM_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

#ifdef NDEBUG
#define RMM_ASSERT_CUDA_SUCCESS_SAFE_SHUTDOWN(_call) \
  do {                                               \
    (_call);                                         \
  } while (0);
#else
#define RMM_ASSERT_CUDA_SUCCESS_SAFE_SHUTDOWN(_call)                            \
  do {                                                                          \
    cudaError_t const status__ = (_call);                                       \
    if (status__ != cudaSuccess && status__ != cudaErrorCudartUnloading) {      \
      std::cerr << "CUDA Error detected. " << cudaGetErrorName(status__) << " " \
                << cudaGetErrorString(status__) << std::endl;                   \
    }                                                                           \
    /* NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) */   \
    assert(status__ == cudaSuccess || status__ == cudaErrorCudartUnloading);    \
  } while (0)
#endif