error.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <cudf/errc.hpp>
#include <cudf/utilities/export.hpp>
 
#include <cuda.h>
#include <cuda_runtime_api.h>
 
#include <stdexcept>
#include <string>
#include <type_traits>
 
namespace CUDF_EXPORT cudf {
struct logic_error : std::logic_error {
  explicit logic_error(char const* const message) : std::logic_error(message) {}
 
  explicit logic_error(std::string const& message) : std::logic_error(message) {}
 
  // TODO Add an error code member? This would be useful for translating an
  // exception to an error code in a pure-C API
 
  ~logic_error() override
  {
    // Needed so that the first instance of the implicit destructor for any TU isn't 'constructed'
    // from a host+device function marking the implicit version also as host+device
  }
};
struct cuda_error : std::runtime_error {
  explicit cuda_error(std::string const& message, cudaError_t const& error)
    : std::runtime_error(message), _cudaError(error)
  {
  }
 
  [[nodiscard]] cudaError_t error_code() const { return _cudaError; }
 
 protected:
  cudaError_t _cudaError;  
};
 
struct fatal_cuda_error : cuda_error {
  using cuda_error::cuda_error;  // Inherit constructors
};
 
struct data_type_error : std::invalid_argument {
  explicit data_type_error(char const* const message) : std::invalid_argument(message) {}
 
  explicit data_type_error(std::string const& message) : std::invalid_argument(message) {}
};
 
struct evaluation_error : public std::exception {
  evaluation_error(errc error, std::string message) : error_(error), message_(std::move(message)) {}
 
  [[nodiscard]] char const* what() const noexcept override { return message_.c_str(); }
 
  [[nodiscard]] errc error_code() const { return error_; }
 
 private:
  errc error_;           //< The error code that occurred during evaluation
  std::string message_;  //< An error message describing the evaluation error
};
 
}  // namespace CUDF_EXPORT cudf
 
#define STRINGIFY_DETAIL(x) #x                   
#define CUDF_STRINGIFY(x)   STRINGIFY_DETAIL(x)  
 
#define CUDF_EXPECTS(...)                                             \
  GET_CUDF_EXPECTS_MACRO(__VA_ARGS__, CUDF_EXPECTS_3, CUDF_EXPECTS_2) \
  (__VA_ARGS__)
 
 
#define GET_CUDF_EXPECTS_MACRO(_1, _2, _3, NAME, ...) NAME
 
#define CUDF_EXPECTS_3(_condition, _reason, _exception_type)           \
  do {                                                                 \
    static_assert(std::is_base_of_v<std::exception, _exception_type>); \
    if (!(_condition)) {                                               \
      cudf::detail::cudf_fail<_exception_type>(                        \
        [&]() -> std::string { return _reason; }, __LINE__, __FILE__); \
    }                                                                  \
  } while (0)
 
#define CUDF_EXPECTS_2(_condition, _reason) CUDF_EXPECTS_3(_condition, _reason, cudf::logic_error)
 
 
#define CUDF_FAIL(...)                                       \
  GET_CUDF_FAIL_MACRO(__VA_ARGS__, CUDF_FAIL_2, CUDF_FAIL_1) \
  (__VA_ARGS__)
 
 
#define GET_CUDF_FAIL_MACRO(_1, _2, NAME, ...) NAME
 
#define CUDF_FAIL_2(_what, _exception_type) \
  cudf::detail::cudf_fail<_exception_type>( \
    [&]() -> std::string { return _what; }, __LINE__, __FILE__)
 
#define CUDF_FAIL_1(_what) CUDF_FAIL_2(_what, cudf::logic_error)
 
 
namespace CUDF_EXPORT cudf {
namespace detail {
// @cond
inline void throw_cuda_error(cudaError_t error, char const* file, unsigned int line)
{
  // Calls cudaGetLastError to clear the error status. It is nearly certain that a fatal error
  // occurred if it still returns the same error after a cleanup.
  cudaGetLastError();
  auto const last = cudaFree(nullptr);
  auto const msg  = std::string{"CUDA error encountered at: " + std::string{file} + ":" +
                               std::to_string(line) + ": " + std::to_string(error) + " " +
                               cudaGetErrorName(error) + " " + cudaGetErrorString(error)};
  // Call cudaDeviceSynchronize to ensure `last` did not result from an asynchronous error.
  // between two calls.
  if (error == last && last == cudaDeviceSynchronize()) {
    throw fatal_cuda_error{"Fatal " + msg, error};
  } else {
    throw cuda_error{msg, error};
  }
}
// @endcond
 
// @cond
template <typename Exception, typename MsgFunc>
[[noreturn]] void cudf_fail(MsgFunc&& msg_func, int line_number, char const* filename)
{
  std::string const msg = std::forward<MsgFunc>(msg_func)();
  throw Exception{std::string{"CUDF failure at: "} + filename + ":" + std::to_string(line_number) +
                  ": " + (msg.empty() ? "(no message)" : msg)};
}
// @endcond
}  // namespace detail
}  // namespace CUDF_EXPORT cudf
 
#define CUDF_CUDA_TRY(call)                                                                    \
  do {                                                                                         \
    cudaError_t const status = (call);                                                         \
    if (cudaSuccess != status) { cudf::detail::throw_cuda_error(status, __FILE__, __LINE__); } \
  } while (0);
 
#ifndef NDEBUG
#define CUDF_CHECK_CUDA(stream)                   \
  do {                                            \
    CUDF_CUDA_TRY(cudaStreamSynchronize(stream)); \
    CUDF_CUDA_TRY(cudaPeekAtLastError());         \
  } while (0);
#else
#define CUDF_CHECK_CUDA(stream) CUDF_CUDA_TRY(cudaPeekAtLastError());
#endif