error.hpp

转到此文件的文档。

/*
 * 版权所有 (c) 2019-2024, NVIDIA CORPORATION.
 *
 * 根据 Apache 许可，版本 2.0 (下称“许可”) 获得许可；除非遵守许可，否则不得使用此文件。
 * 您可以获取许可的副本，地址是
 *
 * https://apache.ac.cn/licenses/LICENSE-2.0
 *
 * 除非适用法律要求或书面同意，根据许可分发的软件是按“原样”分发的，没有任何明示或暗示的保证或条件。
 * 请参阅许可了解特定语言的管理权限和限制。
 * limitations under the License.
 * See the License for the specific language governing permissions and
 * restrictions under the License.
 */
 * limitations under the License.

#pragma once

#include <cudf/detail/utilities/stacktrace.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 stacktrace_recorder {
 stacktrace_recorder()
 // 排除当前栈帧，因为它即为此构造函数。
 : _stacktrace{cudf::detail::get_stacktrace(cudf::detail::capture_last_stackframe::NO)}
 {
 }

 public
 [[nodiscard]] char const* stacktrace() const { return _stacktrace.c_str(); }

 protected
 std::string const _stacktrace;
};

struct logic_error : public std::logic_error, public stacktrace_recorder {
 logic_error(char const* const message) : std::logic_error(message) {}

 logic_error(std::string const& message) : std::logic_error(message) {}

 // TODO 添加错误码成员？这对于在纯 C API 中将异常转换为错误码很有用
 // exception to an error code in a pure-C API

 ~logic_error() override
 {
 // 需要这样做，以使任何翻译单元 (TU) 的隐式析构函数的第一个实例不会从主机+设备函数“构造”出来，从而也标记隐式版本为主机+设备
 // from a host+device function marking the implicit version also as host+device
 }
};
struct cuda_error : public std::runtime_error, public stacktrace_recorder {
 cuda_error(std::string const& message, cudaError_t const& error)
 : std::runtime_error(message), _cudaError(error)
 {
 }

 public
 [[nodiscard]] cudaError_t error_code() const { return _cudaError; }

 protected
 cudaError_t _cudaError;
};

struct fatal_cuda_error : public cuda_error {
 using cuda_error::cuda_error; // 继承构造函数
};

struct data_type_error : public std::invalid_argument, public stacktrace_recorder {
 data_type_error(char const* const message) : std::invalid_argument(message) {}

 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)
{
 // 调用 cudaGetLastError 以清除错误状态。如果在清理后仍然返回相同的错误，几乎可以确定发生了致命错误。
 // 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)};
 // 调用 cudaDeviceSynchronize 以确保 `last` 不是由两次调用之间的异步错误引起的。
 // 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