error.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2023, 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 <cuproj/assert.cuh>
 
#include <cuda_runtime_api.h>
 
#include <stdexcept>
#include <string>
 
namespace cuproj {
 
struct logic_error : public std::logic_error {
  logic_error(char const* const message) : std::logic_error(message) {}
  logic_error(std::string const& message) : std::logic_error(message) {}
};
 
struct cuda_error : public std::runtime_error {
  cuda_error(std::string const& message) : std::runtime_error(message) {}
};
 
}  // namespace cuproj
 
#define CUPROJ_STRINGIFY_DETAIL(x) #x
#define CUPROJ_STRINGIFY(x)        CUPROJ_STRINGIFY_DETAIL(x)
 
#define CUPROJ_EXPECTS(cond, reason)                                    \
  (!!(cond)) ? static_cast<void>(0)                                     \
             : throw cuproj::logic_error("cuProj failure at: " __FILE__ \
                                         ":" CUPROJ_STRINGIFY(__LINE__) ": " reason)
 
#ifndef __CUDA_ARCH__
#define CUPROJ_HOST_DEVICE_EXPECTS(cond, reason) CUPROJ_EXPECTS(cond, reason)
#else
#define CUPROJ_HOST_DEVICE_EXPECTS(cond, reason) cuproj_assert(cond&& reason)
#endif
 
#define CUPROJ_FAIL(reason)                                                      \
  throw cuproj::logic_error("cuProj failure at: " __FILE__ ":" CUPROJ_STRINGIFY( \
    __LINE__) ":"                                                                \
              " " reason)
 
namespace cuproj {
namespace detail {
 
inline void throw_cuda_error(cudaError_t error, const char* file, unsigned int line)
{
  throw cuproj::cuda_error(std::string{"CUDA error encountered at: " + std::string{file} + ":" +
                                       std::to_string(line) + ": " + std::to_string(error) + " " +
                                       cudaGetErrorName(error) + " " + cudaGetErrorString(error)});
}
 
}  // namespace detail
}  // namespace cuproj
 
#define CUPROJ_CUDA_TRY(call)                                       \
  do {                                                              \
    cudaError_t const status = (call);                              \
    if (cudaSuccess != status) {                                    \
      cudaGetLastError();                                           \
      cuproj::detail::throw_cuda_error(status, __FILE__, __LINE__); \
    }                                                               \
  } while (0);
 
#ifndef NDEBUG
#define CUPROJ_CHECK_CUDA(stream)                   \
  do {                                              \
    CUPROJ_CUDA_TRY(cudaStreamSynchronize(stream)); \
    CUPROJ_CUDA_TRY(cudaPeekAtLastError());         \
  } while (0);
#else
#define CUPROJ_CHECK_CUDA(stream) CUPROJ_CUDA_TRY(cudaPeekAtLastError());
#endif