error.hpp

/*
 * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <cstring>
#include <sstream>
#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(const std::string& msg);
  GenericSystemError(const char* msg);
  GenericSystemError(const GenericSystemError& other)            = default;
  GenericSystemError& operator=(const GenericSystemError& other) = default;
  virtual ~GenericSystemError() noexcept                         = default;
};
 
#ifndef CUDA_DRIVER_TRY
#define CUDA_DRIVER_TRY(...)                                                   \
  GET_CUDA_DRIVER_TRY_MACRO(__VA_ARGS__, CUDA_DRIVER_TRY_2, CUDA_DRIVER_TRY_1) \
  (__VA_ARGS__)
#define GET_CUDA_DRIVER_TRY_MACRO(_1, _2, NAME, ...) NAME
#define CUDA_DRIVER_TRY_2(_call, _exception_type)                                  \
  do {                                                                             \
    kvikio::detail::cuda_driver_try_2<_exception_type>(_call, __LINE__, __FILE__); \
  } while (0)
#define CUDA_DRIVER_TRY_1(_call) CUDA_DRIVER_TRY_2(_call, kvikio::CUfileException)
#endif
 
#ifndef CUFILE_TRY
#define CUFILE_TRY(...)                                         \
  GET_CUFILE_TRY_MACRO(__VA_ARGS__, CUFILE_TRY_2, CUFILE_TRY_1) \
  (__VA_ARGS__)
#define GET_CUFILE_TRY_MACRO(_1, _2, NAME, ...) NAME
#define CUFILE_TRY_2(_call, _exception_type)                                  \
  do {                                                                        \
    kvikio::detail::cufile_try_2<_exception_type>(_call, __LINE__, __FILE__); \
  } while (0)
#define CUFILE_TRY_1(_call) CUFILE_TRY_2(_call, kvikio::CUfileException)
#endif
 
#ifndef CUFILE_CHECK_BYTES_DONE
#define CUFILE_CHECK_BYTES_DONE(...)                                   \
  GET_CUFILE_CHECK_BYTES_DONE_MACRO(                                   \
    __VA_ARGS__, CUFILE_CHECK_BYTES_DONE_2, CUFILE_CHECK_BYTES_DONE_1) \
  (__VA_ARGS__)
#define GET_CUFILE_CHECK_BYTES_DONE_MACRO(_1, _2, NAME, ...) NAME
#define CUFILE_CHECK_BYTES_DONE_2(_nbytes_done, _exception_type)                                  \
  do {                                                                                            \
    kvikio::detail::cufile_check_bytes_done_2<_exception_type>(_nbytes_done, __LINE__, __FILE__); \
  } while (0)
#define CUFILE_CHECK_BYTES_DONE_1(_call) CUFILE_CHECK_BYTES_DONE_2(_call, kvikio::CUfileException)
#endif
 
namespace detail {
template <typename Exception>
void cuda_driver_try_2(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_2(CUfileError_t error, int line_number, char const* filename)
{
  if (error.err != CU_FILE_SUCCESS) {
    if (error.err == CU_FILE_CUDA_DRIVER_ERROR) {
      CUresult const cuda_error = error.cu_err;
      CUDA_DRIVER_TRY(cuda_error);
    }
    throw Exception{std::string{"cuFile error at: "} + filename + ":" +
                    std::to_string(line_number) + ": " +
                    cufileop_status_error((CUfileOpError)std::abs(error.err))};
  }
}
 
template <typename Exception>
void cufile_check_bytes_done_2(ssize_t nbytes_done, int line_number, char const* filename)
{
  if (nbytes_done < 0) {
    auto const err = std::abs(nbytes_done);
    auto const msg = (err > CUFILEOP_BASE_ERR)
                       ? std::string(cufileop_status_error((CUfileOpError)err))
                       : std::string(std::strerror(err));
    throw Exception{std::string{"cuFile error at: "} + filename + ":" +
                    std::to_string(line_number) + ": " + msg};
  }
}
 
#define KVIKIO_LOG_ERROR(err_msg) kvikio::detail::log_error(err_msg, __LINE__, __FILE__)
void log_error(std::string_view err_msg, int line_number, char const* filename);
 
}  // namespace detail
 
#define KVIKIO_EXPECT(...) \
  GET_KVIKIO_EXPECT_MACRO(__VA_ARGS__, KVIKIO_EXPECT_3, KVIKIO_EXPECT_2)(__VA_ARGS__)
#define GET_KVIKIO_EXPECT_MACRO(_1, _2, _3, NAME, ...) NAME
 
#define KVIKIO_EXPECT_3(_condition, _msg, _exception_type)                                   \
  do {                                                                                       \
    kvikio::detail::kvikio_assertion<_exception_type>(_condition, _msg, __LINE__, __FILE__); \
  } while (0)
 
#define KVIKIO_EXPECT_2(_condition, _msg) KVIKIO_EXPECT_3(_condition, _msg, kvikio::CUfileException)
 
#define KVIKIO_FAIL(...) \
  GET_KVIKIO_FAIL_MACRO(__VA_ARGS__, KVIKIO_FAIL_2, KVIKIO_FAIL_1)(__VA_ARGS__)
#define GET_KVIKIO_FAIL_MACRO(_1, _2, NAME, ...) NAME
 
#define KVIKIO_FAIL_2(_msg, _exception_type)                                            \
  do {                                                                                  \
    kvikio::detail::kvikio_assertion<_exception_type>(false, _msg, __LINE__, __FILE__); \
  } while (0)
 
#define KVIKIO_FAIL_1(_msg) KVIKIO_FAIL_2(_msg, kvikio::CUfileException)
 
namespace detail {
template <typename Exception>
void kvikio_assertion(bool condition, const char* msg, int line_number, char const* filename)
{
  if (!condition) {
    std::stringstream ss;
    ss << "KvikIO failure at: " << filename << ":" << line_number << ": ";
    if (msg == nullptr) {
      ss << "(no message)";
    } else {
      ss << msg;
    }
    throw Exception{ss.str()};
  };
}
 
template <typename Exception>
void kvikio_assertion(bool condition, const std::string& msg, int line_number, char const* filename)
{
  kvikio_assertion<Exception>(condition, msg.c_str(), line_number, filename);
}
}  // namespace detail
 
#define SYSCALL_CHECK(...)                                                                \
  GET_SYSCALL_CHECK_MACRO(__VA_ARGS__, SYSCALL_CHECK_3, SYSCALL_CHECK_2, SYSCALL_CHECK_1) \
  (__VA_ARGS__)
#define GET_SYSCALL_CHECK_MACRO(_1, _2, _3, NAME, ...) NAME
#define SYSCALL_CHECK_1(_return_value)                                   \
  do {                                                                   \
    kvikio::detail::check_linux_call(__LINE__, __FILE__, _return_value); \
  } while (0)
#define SYSCALL_CHECK_2(_return_value, _extra_msg)                                   \
  do {                                                                               \
    kvikio::detail::check_linux_call(__LINE__, __FILE__, _return_value, _extra_msg); \
  } while (0)
#define SYSCALL_CHECK_3(_return_value, _extra_msg, _error_value)                                   \
  do {                                                                                             \
    kvikio::detail::check_linux_call(__LINE__, __FILE__, _return_value, _extra_msg, _error_value); \
  } while (0)
 
namespace detail {
void handle_linux_call_error(int line_number, char const* filename, std::string_view extra_msg);
 
inline void check_linux_call(int line_number,
                             char const* filename,
                             int return_value,
                             std::string_view extra_msg = "",
                             int error_value            = -1)
{
  if (return_value == error_value) { handle_linux_call_error(line_number, filename, extra_msg); }
}
 
template <typename T>
void check_linux_call(
  int line_number, char const* filename, T return_value, 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