error.hpp

/*
 * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <cstring>
#include <stdexcept>
#include <string>
#include <system_error>
 
#include <kvikio/shim/cuda.hpp>
#include <kvikio/shim/cufile_h_wrapper.hpp>
 
namespace kvikio {
 
struct CUfileException : public std::runtime_error {
  using std::runtime_error::runtime_error;
};
 
class GenericSystemError : public std::system_error {
 public:
  GenericSystemError(int err_code, std::string const& msg);
  GenericSystemError(int err_code, char const* msg);
  GenericSystemError(std::string const& msg);
  GenericSystemError(char const* msg);
  GenericSystemError(GenericSystemError const& other)            = default;
  GenericSystemError& operator=(GenericSystemError const& other) = default;
  virtual ~GenericSystemError() noexcept                         = default;
};
 
#define KVIKIO_VA_SELECT_3(_1, _2, _3, NAME, ...) NAME
#define KVIKIO_VA_SELECT_2(_1, _2, NAME, ...)     NAME
 
#define KVIKIO_CUDA_DRIVER_TRY(...)                                                   \
  KVIKIO_VA_SELECT_2(__VA_ARGS__, KVIKIO_CUDA_DRIVER_TRY_2, KVIKIO_CUDA_DRIVER_TRY_1) \
  (__VA_ARGS__)
#define KVIKIO_CUDA_DRIVER_TRY_2(_call, _exception_type)                         \
  do {                                                                           \
    kvikio::detail::cuda_driver_try<_exception_type>(_call, __LINE__, __FILE__); \
  } while (0)
#define KVIKIO_CUDA_DRIVER_TRY_1(_call) KVIKIO_CUDA_DRIVER_TRY_2(_call, kvikio::CUfileException)
 
#define KVIKIO_CUFILE_TRY(...)                                              \
  KVIKIO_VA_SELECT_2(__VA_ARGS__, KVIKIO_CUFILE_TRY_2, KVIKIO_CUFILE_TRY_1) \
  (__VA_ARGS__)
#define KVIKIO_CUFILE_TRY_2(_call, _exception_type)                         \
  do {                                                                      \
    kvikio::detail::cufile_try<_exception_type>(_call, __LINE__, __FILE__); \
  } while (0)
#define KVIKIO_CUFILE_TRY_1(_call) KVIKIO_CUFILE_TRY_2(_call, kvikio::CUfileException)
 
#define KVIKIO_CUFILE_CHECK_BYTES_DONE(...)                                          \
  KVIKIO_VA_SELECT_2(                                                                \
    __VA_ARGS__, KVIKIO_CUFILE_CHECK_BYTES_DONE_2, KVIKIO_CUFILE_CHECK_BYTES_DONE_1) \
  (__VA_ARGS__)
#define KVIKIO_CUFILE_CHECK_BYTES_DONE_2(_nbytes_done, _exception_type)                         \
  do {                                                                                          \
    kvikio::detail::cufile_check_bytes_done<_exception_type>(_nbytes_done, __LINE__, __FILE__); \
  } while (0)
#define KVIKIO_CUFILE_CHECK_BYTES_DONE_1(_call) \
  KVIKIO_CUFILE_CHECK_BYTES_DONE_2(_call, kvikio::CUfileException)
 
#define KVIKIO_EXPECT(...) \
  KVIKIO_VA_SELECT_3(__VA_ARGS__, KVIKIO_EXPECT_3, KVIKIO_EXPECT_2)(__VA_ARGS__)
// The message argument is wrapped in a lambda to defer evaluation: any expensive expressions (e.g.,
// string concatenation, std::to_string) are only evaluated when the condition fails. Without this,
// the message would be constructed unconditionally at every call site.
#define KVIKIO_EXPECT_3(_condition, _msg, _exception_type)          \
  do {                                                              \
    if (!(_condition)) {                                            \
      kvikio::detail::kvikio_fail<_exception_type>(                 \
        [&]() -> std::string { return _msg; }, __LINE__, __FILE__); \
    }                                                               \
  } while (0)
 
#define KVIKIO_EXPECT_2(_condition, _msg) KVIKIO_EXPECT_3(_condition, _msg, kvikio::CUfileException)
 
#define KVIKIO_FAIL(...) KVIKIO_VA_SELECT_2(__VA_ARGS__, KVIKIO_FAIL_2, KVIKIO_FAIL_1)(__VA_ARGS__)
// Wrap the message in a lambda to defer evaluation. See comments for `KVIKIO_EXPECT_3`
#define KVIKIO_FAIL_2(_msg, _exception_type)    \
  kvikio::detail::kvikio_fail<_exception_type>( \
    [&]() -> std::string { return _msg; }, __LINE__, __FILE__)
 
#define KVIKIO_FAIL_1(_msg) KVIKIO_FAIL_2(_msg, kvikio::CUfileException)
 
#define KVIKIO_SYSCALL_CHECK(...)                                                        \
  KVIKIO_VA_SELECT_3(                                                                    \
    __VA_ARGS__, KVIKIO_SYSCALL_CHECK_3, KVIKIO_SYSCALL_CHECK_2, KVIKIO_SYSCALL_CHECK_1) \
  (__VA_ARGS__)
#define KVIKIO_SYSCALL_CHECK_1(_return_value)                            \
  do {                                                                   \
    kvikio::detail::check_linux_call(_return_value, __LINE__, __FILE__); \
  } while (0)
#define KVIKIO_SYSCALL_CHECK_2(_return_value, _extra_msg)                            \
  do {                                                                               \
    kvikio::detail::check_linux_call(_return_value, __LINE__, __FILE__, _extra_msg); \
  } while (0)
#define KVIKIO_SYSCALL_CHECK_3(_return_value, _extra_msg, _error_value)                            \
  do {                                                                                             \
    kvikio::detail::check_linux_call(_return_value, __LINE__, __FILE__, _extra_msg, _error_value); \
  } while (0)
 
namespace detail {
template <typename Exception, typename MsgFunc>
[[noreturn]] void kvikio_fail(MsgFunc&& msg_func, int line_number, char const* filename)
{
  std::string const msg = std::forward<MsgFunc>(msg_func)();
  throw Exception{std::string{"KvikIO failure at: "} + filename + ":" +
                  std::to_string(line_number) + ": " + (msg.empty() ? "(no message)" : msg)};
}
 
template <typename Exception>
void cuda_driver_try(CUresult error, int line_number, char const* filename)
{
  if (error == CUDA_ERROR_STUB_LIBRARY) {
    throw Exception{std::string{"CUDA error at: "} + std::string(filename) + ":" +
                    std::to_string(line_number) +
                    ": CUDA_ERROR_STUB_LIBRARY("
                    "The CUDA driver loaded is a stub library)"};
  }
  if (error != CUDA_SUCCESS) {
    char const* err_name     = nullptr;
    char const* err_str      = nullptr;
    CUresult err_name_status = cudaAPI::instance().GetErrorName(error, &err_name);
    CUresult err_str_status  = cudaAPI::instance().GetErrorString(error, &err_str);
    if (err_name_status == CUDA_ERROR_INVALID_VALUE) { err_name = "unknown"; }
    if (err_str_status == CUDA_ERROR_INVALID_VALUE) { err_str = "unknown"; }
    throw Exception{std::string{"CUDA error at: "} + filename + ":" + std::to_string(line_number) +
                    ": " + std::string(err_name) + "(" + std::string(err_str) + ")"};
  }
}
 
template <typename Exception>
void cufile_try(CUfileError_t error, int line_number, char const* filename)
{
  if (error.err != CU_FILE_SUCCESS) {
    if (error.err == CU_FILE_CUDA_DRIVER_ERROR) {
      cuda_driver_try<Exception>(error.cu_err, line_number, filename);
    }
    throw Exception{std::string{"cuFile error at: "} + filename + ":" +
                    std::to_string(line_number) + ": " + cufileop_status_error(error.err)};
  }
}
 
template <typename Exception>
void cufile_check_bytes_done(ssize_t nbytes_done, int line_number, char const* filename)
{
  if (nbytes_done < 0) {
    auto const err = static_cast<long>(-nbytes_done);
    auto const msg = (err > CUFILEOP_BASE_ERR)
                       ? std::string(cufileop_status_error(static_cast<CUfileOpError>(err)))
                       : std::string(std::strerror(err));
    throw Exception{std::string{"cuFile error at: "} + filename + ":" +
                    std::to_string(line_number) + ": " + msg};
  }
}
 
[[noreturn]] inline void handle_linux_call_error(int line_number,
                                                 char const* filename,
                                                 std::string_view extra_msg)
{
  auto msg = extra_msg.empty() ? std::string{} : (std::string{extra_msg} + " ");
  msg += std::string{"Linux system/library function call error at: "} + filename + ":" +
         std::to_string(line_number);
  // std::system_error::what() automatically contains the detailed error description
  // equivalent to calling strerror(errno)
  throw kvikio::GenericSystemError(msg);
}
 
inline void check_linux_call(long return_value,
                             int line_number,
                             char const* filename,
                             std::string_view extra_msg = "",
                             long error_value           = -1)
{
  if (return_value == error_value) { handle_linux_call_error(line_number, filename, extra_msg); }
}
 
template <typename T>
void check_linux_call(
  T return_value, int line_number, char const* filename, std::string_view extra_msg, T error_value)
{
  if (return_value == error_value) { handle_linux_call_error(line_number, filename, extra_msg); }
}
 
}  // namespace detail
 
}  // namespace kvikio