271 lines
9.1 KiB
C++
271 lines
9.1 KiB
C++
/* Copyright 2015-2017 Philippe Tillet
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files
|
|
* (the "Software"), to deal in the Software without restriction,
|
|
* including without limitation the rights to use, copy, modify, merge,
|
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
|
* and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "triton/driver/error.h"
|
|
|
|
namespace triton {
|
|
namespace driver {
|
|
|
|
void check(CUresult err) {
|
|
using namespace exception::cuda;
|
|
switch (err) {
|
|
case CUDA_SUCCESS:
|
|
break;
|
|
case CUDA_ERROR_INVALID_VALUE:
|
|
throw invalid_value();
|
|
case CUDA_ERROR_OUT_OF_MEMORY:
|
|
throw out_of_memory();
|
|
case CUDA_ERROR_NOT_INITIALIZED:
|
|
throw not_initialized();
|
|
case CUDA_ERROR_DEINITIALIZED:
|
|
throw deinitialized();
|
|
case CUDA_ERROR_PROFILER_DISABLED:
|
|
throw profiler_disabled();
|
|
case CUDA_ERROR_PROFILER_NOT_INITIALIZED:
|
|
throw profiler_not_initialized();
|
|
case CUDA_ERROR_PROFILER_ALREADY_STARTED:
|
|
throw profiler_already_started();
|
|
case CUDA_ERROR_PROFILER_ALREADY_STOPPED:
|
|
throw profiler_already_stopped();
|
|
case CUDA_ERROR_NO_DEVICE:
|
|
throw no_device();
|
|
case CUDA_ERROR_INVALID_DEVICE:
|
|
throw invalid_device();
|
|
case CUDA_ERROR_INVALID_IMAGE:
|
|
throw invalid_image();
|
|
case CUDA_ERROR_INVALID_CONTEXT:
|
|
throw invalid_context();
|
|
case CUDA_ERROR_CONTEXT_ALREADY_CURRENT:
|
|
throw context_already_current();
|
|
case CUDA_ERROR_MAP_FAILED:
|
|
throw map_failed();
|
|
case CUDA_ERROR_UNMAP_FAILED:
|
|
throw unmap_failed();
|
|
case CUDA_ERROR_ARRAY_IS_MAPPED:
|
|
throw array_is_mapped();
|
|
case CUDA_ERROR_ALREADY_MAPPED:
|
|
throw already_mapped();
|
|
case CUDA_ERROR_NO_BINARY_FOR_GPU:
|
|
throw no_binary_for_gpu();
|
|
case CUDA_ERROR_ALREADY_ACQUIRED:
|
|
throw already_acquired();
|
|
case CUDA_ERROR_NOT_MAPPED:
|
|
throw not_mapped();
|
|
case CUDA_ERROR_NOT_MAPPED_AS_ARRAY:
|
|
throw not_mapped_as_array();
|
|
case CUDA_ERROR_NOT_MAPPED_AS_POINTER:
|
|
throw not_mapped_as_pointer();
|
|
case CUDA_ERROR_ECC_UNCORRECTABLE:
|
|
throw ecc_uncorrectable();
|
|
case CUDA_ERROR_UNSUPPORTED_LIMIT:
|
|
throw unsupported_limit();
|
|
case CUDA_ERROR_CONTEXT_ALREADY_IN_USE:
|
|
throw context_already_in_use();
|
|
case CUDA_ERROR_PEER_ACCESS_UNSUPPORTED:
|
|
throw peer_access_unsupported();
|
|
case CUDA_ERROR_INVALID_PTX:
|
|
throw invalid_ptx();
|
|
case CUDA_ERROR_INVALID_GRAPHICS_CONTEXT:
|
|
throw invalid_graphics_context();
|
|
case CUDA_ERROR_INVALID_SOURCE:
|
|
throw invalid_source();
|
|
case CUDA_ERROR_FILE_NOT_FOUND:
|
|
throw file_not_found();
|
|
case CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND:
|
|
throw shared_object_symbol_not_found();
|
|
case CUDA_ERROR_SHARED_OBJECT_INIT_FAILED:
|
|
throw shared_object_init_failed();
|
|
case CUDA_ERROR_OPERATING_SYSTEM:
|
|
throw operating_system();
|
|
case CUDA_ERROR_INVALID_HANDLE:
|
|
throw invalid_handle();
|
|
case CUDA_ERROR_NOT_FOUND:
|
|
throw not_found();
|
|
case CUDA_ERROR_NOT_READY:
|
|
throw not_ready();
|
|
case CUDA_ERROR_ILLEGAL_ADDRESS:
|
|
throw illegal_address();
|
|
case CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES:
|
|
throw launch_out_of_resources();
|
|
case CUDA_ERROR_LAUNCH_TIMEOUT:
|
|
throw launch_timeout();
|
|
case CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING:
|
|
throw launch_incompatible_texturing();
|
|
case CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED:
|
|
throw peer_access_already_enabled();
|
|
case CUDA_ERROR_PEER_ACCESS_NOT_ENABLED:
|
|
throw peer_access_not_enabled();
|
|
case CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE:
|
|
throw primary_context_active();
|
|
case CUDA_ERROR_CONTEXT_IS_DESTROYED:
|
|
throw context_is_destroyed();
|
|
case CUDA_ERROR_ASSERT:
|
|
throw assert_error();
|
|
case CUDA_ERROR_TOO_MANY_PEERS:
|
|
throw too_many_peers();
|
|
case CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED:
|
|
throw host_memory_already_registered();
|
|
case CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED:
|
|
throw host_memory_not_registered();
|
|
case CUDA_ERROR_HARDWARE_STACK_ERROR:
|
|
throw hardware_stack_error();
|
|
case CUDA_ERROR_ILLEGAL_INSTRUCTION:
|
|
throw illegal_instruction();
|
|
case CUDA_ERROR_MISALIGNED_ADDRESS:
|
|
throw misaligned_address();
|
|
case CUDA_ERROR_INVALID_ADDRESS_SPACE:
|
|
throw invalid_address_space();
|
|
case CUDA_ERROR_INVALID_PC:
|
|
throw invalid_pc();
|
|
case CUDA_ERROR_LAUNCH_FAILED:
|
|
throw launch_failed();
|
|
case CUDA_ERROR_NOT_PERMITTED:
|
|
throw not_permitted();
|
|
case CUDA_ERROR_NOT_SUPPORTED:
|
|
throw not_supported();
|
|
case CUDA_ERROR_UNKNOWN:
|
|
throw unknown();
|
|
default:
|
|
throw unknown();
|
|
}
|
|
}
|
|
|
|
void check(hipError_t error) {
|
|
using namespace exception::hip;
|
|
switch (error) {
|
|
case hipSuccess:
|
|
break;
|
|
case hipErrorInvalidValue:
|
|
throw invalid_value();
|
|
case hipErrorMemoryAllocation:
|
|
throw out_of_memory();
|
|
case hipErrorNotInitialized:
|
|
throw not_initialized();
|
|
case hipErrorDeinitialized:
|
|
throw deinitialized();
|
|
case hipErrorProfilerDisabled:
|
|
throw profiler_disabled();
|
|
case hipErrorProfilerNotInitialized:
|
|
throw profiler_not_initialized();
|
|
case hipErrorProfilerAlreadyStarted:
|
|
throw profiler_already_started();
|
|
case hipErrorProfilerAlreadyStopped:
|
|
throw profiler_already_stopped();
|
|
case hipErrorNoDevice:
|
|
throw no_device();
|
|
case hipErrorInvalidSymbol:
|
|
throw invalid_symbol();
|
|
case hipErrorInvalidDevice:
|
|
throw invalid_device();
|
|
case hipErrorInvalidImage:
|
|
throw invalid_image();
|
|
case hipErrorInvalidContext:
|
|
throw invalid_context();
|
|
case hipErrorContextAlreadyCurrent:
|
|
throw context_already_current();
|
|
case hipErrorMapFailed:
|
|
throw map_failed();
|
|
case hipErrorUnmapFailed:
|
|
throw unmap_failed();
|
|
case hipErrorArrayIsMapped:
|
|
throw array_is_mapped();
|
|
case hipErrorAlreadyMapped:
|
|
throw already_mapped();
|
|
case hipErrorNoBinaryForGpu:
|
|
throw no_binary_for_gpu();
|
|
case hipErrorAlreadyAcquired:
|
|
throw already_acquired();
|
|
case hipErrorNotMapped:
|
|
throw not_mapped();
|
|
case hipErrorNotMappedAsArray:
|
|
throw not_mapped_as_array();
|
|
case hipErrorNotMappedAsPointer:
|
|
throw not_mapped_as_pointer();
|
|
case hipErrorECCNotCorrectable:
|
|
throw ecc_uncorrectable();
|
|
case hipErrorUnsupportedLimit:
|
|
throw unsupported_limit();
|
|
case hipErrorContextAlreadyInUse:
|
|
throw context_already_in_use();
|
|
case hipErrorPeerAccessUnsupported:
|
|
throw peer_access_unsupported();
|
|
case hipErrorInvalidKernelFile:
|
|
throw invalid_ptx();
|
|
case hipErrorInvalidGraphicsContext:
|
|
throw invalid_graphics_context();
|
|
case hipErrorInvalidSource:
|
|
throw invalid_source();
|
|
case hipErrorFileNotFound:
|
|
throw file_not_found();
|
|
case hipErrorSharedObjectSymbolNotFound:
|
|
throw shared_object_symbol_not_found();
|
|
case hipErrorSharedObjectInitFailed:
|
|
throw shared_object_init_failed();
|
|
case hipErrorOperatingSystem:
|
|
throw operating_system();
|
|
case hipErrorInvalidResourceHandle:
|
|
throw invalid_handle();
|
|
case hipErrorNotFound:
|
|
throw not_found();
|
|
case hipErrorNotReady:
|
|
throw not_ready();
|
|
case hipErrorIllegalAddress:
|
|
throw illegal_address();
|
|
case hipErrorLaunchOutOfResources:
|
|
throw launch_out_of_resources();
|
|
case hipErrorLaunchTimeOut:
|
|
throw launch_timeout();
|
|
// case hipErrorLaunchIncompatibleTexturing : throw
|
|
// launch_incompatible_texturing();
|
|
case hipErrorPeerAccessAlreadyEnabled:
|
|
throw peer_access_already_enabled();
|
|
case hipErrorPeerAccessNotEnabled:
|
|
throw peer_access_not_enabled();
|
|
// case hipErrorPrimaryContextActive : throw primary_context_active();
|
|
// case hipErrorContextIsDestroyed : throw context_is_destroyed();
|
|
case hipErrorAssert:
|
|
throw assert_error();
|
|
// case hipErrorTooManyPeers : throw too_many_peers();
|
|
case hipErrorHostMemoryAlreadyRegistered:
|
|
throw host_memory_already_registered();
|
|
case hipErrorHostMemoryNotRegistered:
|
|
throw host_memory_not_registered();
|
|
// case hipErrorHardwareStackError : throw hardware_stack_error();
|
|
// case hipErrorIllegalInstruction : throw illegal_instruction();
|
|
// case hipErrorMisalignedAddress : throw misaligned_address();
|
|
// case hipErrorInvalidAddressSpace : throw invalid_address_space();
|
|
// case hipErrorInvalidPc : throw invalid_pc();
|
|
case hipErrorLaunchFailure:
|
|
throw launch_failed();
|
|
// case hipErrorNotPermitted : throw not_permitted();
|
|
case hipErrorNotSupported:
|
|
throw not_supported();
|
|
case hipErrorUnknown:
|
|
throw unknown();
|
|
default:
|
|
throw unknown();
|
|
}
|
|
}
|
|
|
|
} // namespace driver
|
|
} // namespace triton
|