HIP backend: copy errro.h/inl from CUDA backend
thrust/system/cuda/detail/error.inl -> thrust/system/hip/detail/error.inl
thrust/system/cuda/detail/guarded_cuda_runtime_api.h -> thrust/system/hip/detail/guarded_hip_runtime_api.h
thrust/system/cuda/error.h -> thrust/system/hip/error.h
ADD
thrust/system/hip/detail/error.inl
+/*
+ * Copyright 2008-2013 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 <thrust/system/cuda/error.h>
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+
+namespace thrust
+{
+
+namespace system
+{
+
+
+error_code make_error_code(cuda_cub::errc::errc_t e)
+{
+ return error_code(static_cast<int>(e), cuda_category());
+} // end make_error_code()
+
+
+error_condition make_error_condition(cuda_cub::errc::errc_t e)
+{
+ return error_condition(static_cast<int>(e), cuda_category());
+} // end make_error_condition()
+
+
+namespace cuda_cub
+{
+
+namespace detail
+{
+
+
+class cuda_error_category
+ : public error_category
+{
+ public:
+ inline cuda_error_category(void) {}
+
+ inline virtual const char *name(void) const
+ {
+ return "cuda";
+ }
+
+ inline virtual std::string message(int ev) const
+ {
+ static const std::string unknown_err("Unknown error");
+ const char *c_str = ::cudaGetErrorString(static_cast<cudaError_t>(ev));
+ return c_str ? std::string(c_str) : unknown_err;
+ }
+
+ inline virtual error_condition default_error_condition(int ev) const
+ {
+ using namespace cuda_cub::errc;
+
+ if(ev < ::cudaErrorApiFailureBase)
+ {
+ return make_error_condition(static_cast<errc_t>(ev));
+ }
+
+ return system_category().default_error_condition(ev);
+ }
+}; // end cuda_error_category
+
+} // end detail
+
+} // end namespace cuda_cub
+
+
+const error_category &cuda_category(void)
+{
+ static const cuda_cub::detail::cuda_error_category result;
+ return result;
+}
+
+
+} // end namespace system
+
+} // end namespace thrust
+

ADD
thrust/system/hip/detail/guarded_hip_runtime_api.h
+/*
+ * Copyright 2008-2013 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 <thrust/detail/config.h>
+
+// the purpose of this header is to check for the existence of macros
+// such as __host__ and __device__, which may already be defined by thrust
+// and to undefine them before entering cuda_runtime_api.h (which will redefine them)
+
+// we only try to do this stuff if cuda/include/host_defines.h has been included
+#if !defined(__HOST_DEFINES_H__)
+
+#ifdef __host__
+#undef __host__
+#endif // __host__
+
+#ifdef __device__
+#undef __device__
+#endif // __device__
+
+#endif // __HOST_DEFINES_H__
+
+#include <cuda_runtime_api.h>
+

ADD
thrust/system/hip/error.h
+/*
+ * Copyright 2008-2013 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 <thrust/system/cuda/detail/guarded_driver_types.h>
+
+namespace thrust
+{
+
+namespace system
+{
+
+namespace cuda_cub
+{
+
+/*! \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_cub
+
+/*! \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_cub::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_cub::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_cub::errc::errc_t e);
+
+/*! \} // end system
+ */
+
+
+} // end system
+
+namespace system {
+namespace cuda {
+namespace errc {
+using system::cuda_cub::errc::errc_t;
+} // namespace errc
+} // namespace cuda
+} // namespace system
+
+namespace cuda
+{
+// XXX replace with using system::cuda_errc upon c++0x
+namespace errc = system::cuda::errc;
+} // end cuda_cub
+
+using system::cuda_category;
+
+} // end namespace thrust
+
+#include <thrust/system/cuda/detail/error.inl>
+

HIP backend: copy errro.h/inl from CUDA backend

thrust/system/cuda/detail/error.inl -> thrust/system/hip/detail/error.inl
thrust/system/cuda/detail/guarded_cuda_runtime_api.h -> thrust/system/hip/detail/guarded_hip_runtime_api.h
thrust/system/cuda/error.h -> thrust/system/hip/error.h