error.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2025, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#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) {}
};
}  // 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>);          \
    (_condition) ? static_cast<void>(0)                                         \
                 : throw _exception_type /*NOLINT(bugprone-macro-parentheses)*/ \
      {"CUDF failure at: " __FILE__ ":" CUDF_STRINGIFY(__LINE__) ": " _reason}; \
  } 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)      \
  /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/ \
  throw _exception_type { "CUDF failure at:" __FILE__ ":" CUDF_STRINGIFY(__LINE__) ": " _what }
 
#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
}  // 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