You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
186 lines
7.3 KiB
186 lines
7.3 KiB
/* |
|
* Copyright 2008-2012 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. |
|
*/ |
|
|
|
|
|
/*! \file thrust/system/cuda/error.h |
|
* \brief CUDA-specific error reporting |
|
*/ |
|
|
|
#pragma once |
|
|
|
#include <thrust/detail/config.h> |
|
#include <thrust/detail/type_traits.h> |
|
#include <thrust/system/error_code.h> |
|
#include <driver_types.h> |
|
|
|
namespace thrust |
|
{ |
|
|
|
namespace system |
|
{ |
|
|
|
namespace cuda |
|
{ |
|
|
|
/*! \addtogroup system |
|
* \{ |
|
*/ |
|
|
|
// To construct an error_code after a CUDA Runtime error: |
|
// |
|
// error_code(::cudaGetLastError(), cuda_category()) |
|
|
|
// XXX N3000 prefers enum class errc { ... } |
|
namespace errc |
|
{ |
|
|
|
/*! \p errc_t enumerates the kinds of CUDA Runtime errors. |
|
*/ |
|
enum errc_t |
|
{ |
|
// from cuda/include/driver_types.h |
|
// mirror their order |
|
success = cudaSuccess, |
|
missing_configuration = cudaErrorMissingConfiguration, |
|
memory_allocation = cudaErrorMemoryAllocation, |
|
initialization_error = cudaErrorInitializationError, |
|
launch_failure = cudaErrorLaunchFailure, |
|
prior_launch_failure = cudaErrorPriorLaunchFailure, |
|
launch_timeout = cudaErrorLaunchTimeout, |
|
launch_out_of_resources = cudaErrorLaunchOutOfResources, |
|
invalid_device_function = cudaErrorInvalidDeviceFunction, |
|
invalid_configuration = cudaErrorInvalidConfiguration, |
|
invalid_device = cudaErrorInvalidDevice, |
|
invalid_value = cudaErrorInvalidValue, |
|
invalid_pitch_value = cudaErrorInvalidPitchValue, |
|
invalid_symbol = cudaErrorInvalidSymbol, |
|
map_buffer_object_failed = cudaErrorMapBufferObjectFailed, |
|
unmap_buffer_object_failed = cudaErrorUnmapBufferObjectFailed, |
|
invalid_host_pointer = cudaErrorInvalidHostPointer, |
|
invalid_device_pointer = cudaErrorInvalidDevicePointer, |
|
invalid_texture = cudaErrorInvalidTexture, |
|
invalid_texture_binding = cudaErrorInvalidTextureBinding, |
|
invalid_channel_descriptor = cudaErrorInvalidChannelDescriptor, |
|
invalid_memcpy_direction = cudaErrorInvalidMemcpyDirection, |
|
address_of_constant_error = cudaErrorAddressOfConstant, |
|
texture_fetch_failed = cudaErrorTextureFetchFailed, |
|
texture_not_bound = cudaErrorTextureNotBound, |
|
synchronization_error = cudaErrorSynchronizationError, |
|
invalid_filter_setting = cudaErrorInvalidFilterSetting, |
|
invalid_norm_setting = cudaErrorInvalidNormSetting, |
|
mixed_device_execution = cudaErrorMixedDeviceExecution, |
|
cuda_runtime_unloading = cudaErrorCudartUnloading, |
|
unknown = cudaErrorUnknown, |
|
not_yet_implemented = cudaErrorNotYetImplemented, |
|
memory_value_too_large = cudaErrorMemoryValueTooLarge, |
|
invalid_resource_handle = cudaErrorInvalidResourceHandle, |
|
not_ready = cudaErrorNotReady, |
|
insufficient_driver = cudaErrorInsufficientDriver, |
|
set_on_active_process_error = cudaErrorSetOnActiveProcess, |
|
no_device = cudaErrorNoDevice, |
|
ecc_uncorrectable = cudaErrorECCUncorrectable, |
|
|
|
#if CUDART_VERSION >= 4020 |
|
shared_object_symbol_not_found = cudaErrorSharedObjectSymbolNotFound, |
|
shared_object_init_failed = cudaErrorSharedObjectInitFailed, |
|
unsupported_limit = cudaErrorUnsupportedLimit, |
|
duplicate_variable_name = cudaErrorDuplicateVariableName, |
|
duplicate_texture_name = cudaErrorDuplicateTextureName, |
|
duplicate_surface_name = cudaErrorDuplicateSurfaceName, |
|
devices_unavailable = cudaErrorDevicesUnavailable, |
|
invalid_kernel_image = cudaErrorInvalidKernelImage, |
|
no_kernel_image_for_device = cudaErrorNoKernelImageForDevice, |
|
incompatible_driver_context = cudaErrorIncompatibleDriverContext, |
|
peer_access_already_enabled = cudaErrorPeerAccessAlreadyEnabled, |
|
peer_access_not_enabled = cudaErrorPeerAccessNotEnabled, |
|
device_already_in_use = cudaErrorDeviceAlreadyInUse, |
|
profiler_disabled = cudaErrorProfilerDisabled, |
|
assert_triggered = cudaErrorAssert, |
|
too_many_peers = cudaErrorTooManyPeers, |
|
host_memory_already_registered = cudaErrorHostMemoryAlreadyRegistered, |
|
host_memory_not_registered = cudaErrorHostMemoryNotRegistered, |
|
operating_system_error = cudaErrorOperatingSystem, |
|
#endif |
|
|
|
#if CUDART_VERSION >= 5000 |
|
peer_access_unsupported = cudaErrorPeerAccessUnsupported, |
|
launch_max_depth_exceeded = cudaErrorLaunchMaxDepthExceeded, |
|
launch_file_scoped_texture_used = cudaErrorLaunchFileScopedTex, |
|
launch_file_scoped_surface_used = cudaErrorLaunchFileScopedSurf, |
|
sync_depth_exceeded = cudaErrorSyncDepthExceeded, |
|
attempted_operation_not_permitted = cudaErrorNotPermitted, |
|
attempted_operation_not_supported = cudaErrorNotSupported, |
|
#endif |
|
|
|
startup_failure = cudaErrorStartupFailure |
|
}; // end errc_t |
|
|
|
|
|
} // end namespace errc |
|
|
|
} // end namespace cuda |
|
|
|
/*! \return A reference to an object of a type derived from class \p thrust::error_category. |
|
* \note The object's \p equivalent virtual functions shall behave as specified |
|
* for the class \p thrust::error_category. The object's \p name virtual function shall |
|
* return a pointer to the string <tt>"cuda"</tt>. The object's |
|
* \p default_error_condition virtual function shall behave as follows: |
|
* |
|
* If the argument <tt>ev</tt> corresponds to a CUDA error value, the function |
|
* shall return <tt>error_condition(ev,cuda_category())</tt>. |
|
* Otherwise, the function shall return <tt>system_category.default_error_condition(ev)</tt>. |
|
*/ |
|
inline const error_category &cuda_category(void); |
|
|
|
|
|
// XXX N3000 prefers is_error_code_enum<cuda::errc> |
|
|
|
/*! Specialization of \p is_error_code_enum for \p cuda::errc::errc_t |
|
*/ |
|
template<> struct is_error_code_enum<cuda::errc::errc_t> : thrust::detail::true_type {}; |
|
|
|
|
|
// XXX replace cuda::errc::errc_t with cuda::errc upon c++0x |
|
/*! \return <tt>error_code(static_cast<int>(e), cuda::error_category())</tt> |
|
*/ |
|
inline error_code make_error_code(cuda::errc::errc_t e); |
|
|
|
|
|
// XXX replace cuda::errc::errc_t with cuda::errc upon c++0x |
|
/*! \return <tt>error_condition(static_cast<int>(e), cuda::error_category())</tt>. |
|
*/ |
|
inline error_condition make_error_condition(cuda::errc::errc_t e); |
|
|
|
/*! \} // end system |
|
*/ |
|
|
|
|
|
} // end system |
|
|
|
namespace cuda |
|
{ |
|
|
|
// XXX replace with using system::cuda_errc upon c++0x |
|
namespace errc = system::cuda::errc; |
|
|
|
} // end cuda |
|
|
|
using system::cuda_category; |
|
|
|
} // end namespace thrust |
|
|
|
#include <thrust/system/cuda/detail/error.inl> |
|
|
|
|