/*
* JCuda - Java bindings for NVIDIA CUDA driver and runtime API
*
* Copyright (c) 2009-2012 Marco Hutter - http://www.jcuda.org
*
* 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.
*/
//package jcuda.driver;
package com.sheepit.client.hardware.gpu;
/**
* Error codes.<br />
* <br />
* Most comments are taken from the CUDA reference manual.
*/
public class CUresult {
/**
* The API call returned with no errors. In the case of query calls, this
* can also mean that the operation being queried is complete (see
* ::cuEventQuery() and ::cuStreamQuery()).
*/
public static final int CUDA_SUCCESS = 0;
/**
* This indicates that one or more of the parameters passed to the API call
* is not within an acceptable range of values.
*/
public static final int CUDA_ERROR_INVALID_VALUE = 1;
/**
* The API call failed because it was unable to allocate enough memory to
* perform the requested operation.
*/
public static final int CUDA_ERROR_OUT_OF_MEMORY = 2;
/**
* This indicates that the CUDA driver has not been initialized with
* ::cuInit() or that initialization has failed.
*/
public static final int CUDA_ERROR_NOT_INITIALIZED = 3;
/**
* This indicates that the CUDA driver is in the process of shutting down.
*/
public static final int CUDA_ERROR_DEINITIALIZED = 4;
/**
* This indicates profiling APIs are called while application is running
* in visual profiler mode.
*/
public static final int CUDA_ERROR_PROFILER_DISABLED = 5;
/**
* This indicates profiling has not been initialized for this context.
* Call cuProfilerInitialize() to resolve this.
*
* @deprecated This error return is deprecated as of CUDA 5.0.
* It is no longer an error to attempt to enable/disable the
* profiling via ::cuProfilerStart or ::cuProfilerStop without
* initialization.
*/
public static final int CUDA_ERROR_PROFILER_NOT_INITIALIZED = 6;
/**
* This indicates profiler has already been started and probably
* cuProfilerStart() is incorrectly called.
*
* @deprecated This error return is deprecated as of CUDA 5.0.
* It is no longer an error to call cuProfilerStart() when
* profiling is already enabled.
*/
public static final int CUDA_ERROR_PROFILER_ALREADY_STARTED = 7;
/**
* This indicates profiler has already been stopped and probably
* cuProfilerStop() is incorrectly called.
*
* @deprecated This error return is deprecated as of CUDA 5.0.
* It is no longer an error to call cuProfilerStop() when
* profiling is already disabled.
*/
public static final int CUDA_ERROR_PROFILER_ALREADY_STOPPED = 8;
/**
* This indicates that no CUDA-capable devices were detected by the installed
* CUDA driver.
*/
public static final int CUDA_ERROR_NO_DEVICE = 100;
/**
* This indicates that the device ordinal supplied by the user does not
* correspond to a valid CUDA device.
*/
public static final int CUDA_ERROR_INVALID_DEVICE = 101;
/**
* This indicates that the device kernel image is invalid. This can also
* indicate an invalid CUDA module.
*/
public static final int CUDA_ERROR_INVALID_IMAGE = 200;
/**
* This most frequently indicates that there is no context bound to the
* current thread. This can also be returned if the context passed to an
* API call is not a valid handle (such as a context that has had
* ::cuCtxDestroy() invoked on it). This can also be returned if a user
* mixes different API versions (i.e. 3010 context with 3020 API calls).
* See ::cuCtxGetApiVersion() for more details.
*/
public static final int CUDA_ERROR_INVALID_CONTEXT = 201;
/**
* This indicated that the context being supplied as a parameter to the
* API call was already the active context.
* \deprecated
* This error return is deprecated as of CUDA 3.2. It is no longer an
* error to attempt to push the active context via ::cuCtxPushCurrent().
*/
public static final int CUDA_ERROR_CONTEXT_ALREADY_CURRENT = 202;
/**
* This indicates that a map or register operation has failed.
*/
public static final int CUDA_ERROR_MAP_FAILED = 205;
/**
* This indicates that an unmap or unregister operation has failed.
*/
public static final int CUDA_ERROR_UNMAP_FAILED = 206;
/**
* This indicates that the specified array is currently mapped and thus
* cannot be destroyed.
*/
public static final int CUDA_ERROR_ARRAY_IS_MAPPED = 207;
/**
* This indicates that the resource is already mapped.
*/
public static final int CUDA_ERROR_ALREADY_MAPPED = 208;
/**
* This indicates that there is no kernel image available that is suitable
* for the device. This can occur when a user specifies code generation
* options for a particular CUDA source file that do not include the
* corresponding device configuration.
*/
public static final int CUDA_ERROR_NO_BINARY_FOR_GPU = 209;
/**
* This indicates that a resource has already been acquired.
*/
public static final int CUDA_ERROR_ALREADY_ACQUIRED = 210;
/**
* This indicates that a resource is not mapped.
*/
public static final int CUDA_ERROR_NOT_MAPPED = 211;
/**
* This indicates that a mapped resource is not available for access as an
* array.
*/
public static final int CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212;
/**
* This indicates that a mapped resource is not available for access as a
* pointer.
*/
public static final int CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213;
/**
* This indicates that an uncorrectable ECC error was detected during
* execution.
*/
public static final int CUDA_ERROR_ECC_UNCORRECTABLE = 214;
/**
* This indicates that the ::CUlimit passed to the API call is not
* supported by the active device.
*/
public static final int CUDA_ERROR_UNSUPPORTED_LIMIT = 215;
/**
* This indicates that the ::CUcontext passed to the API call can
* only be bound to a single CPU thread at a time but is already
* bound to a CPU thread.
*/
public static final int CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216;
/**
* This indicates that peer access is not supported across the given
* devices.
*/
public static final int CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217;
/**
* This indicates that the device kernel source is invalid.
*/
public static final int CUDA_ERROR_INVALID_SOURCE = 300;
/**
* This indicates that the file specified was not found.
*/
public static final int CUDA_ERROR_FILE_NOT_FOUND = 301;
/**
* This indicates that a link to a shared object failed to resolve.
*/
public static final int CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302;
/**
* This indicates that initialization of a shared object failed.
*/
public static final int CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303;
/**
* This indicates that an OS call failed.
*/
public static final int CUDA_ERROR_OPERATING_SYSTEM = 304;
/**
* This indicates that a resource handle passed to the API call was not
* valid. Resource handles are opaque types like ::CUstream and ::CUevent.
*/
public static final int CUDA_ERROR_INVALID_HANDLE = 400;
/**
* This indicates that a named symbol was not found. Examples of symbols
* are global/constant variable names, texture names, and surface names.
*/
public static final int CUDA_ERROR_NOT_FOUND = 500;
/**
* This indicates that asynchronous operations issued previously have not
* completed yet. This result is not actually an error, but must be indicated
* differently than ::CUDA_SUCCESS (which indicates completion). Calls that
* may return this value include ::cuEventQuery() and ::cuStreamQuery().
*/
public static final int CUDA_ERROR_NOT_READY = 600;
/**
* An exception occurred on the device while executing a kernel. Common
* causes include dereferencing an invalid device pointer and accessing
* out of bounds shared memory. The context cannot be used, so it must
* be destroyed (and a new one should be created). All existing device
* memory allocations from this context are invalid and must be
* reconstructed if the program is to continue using CUDA.
*/
public static final int CUDA_ERROR_LAUNCH_FAILED = 700;
/**
* This indicates that a launch did not occur because it did not have
* appropriate resources. This error usually indicates that the user has
* attempted to pass too many arguments to the device kernel, or the
* kernel launch specifies too many threads for the kernel's register
* count. Passing arguments of the wrong size (i.e. a 64-bit pointer
* when a 32-bit int is expected) is equivalent to passing too many
* arguments and can also result in this error.
*/
public static final int CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701;
/**
* This indicates that the device kernel took too long to execute. This can
* only occur if timeouts are enabled - see the device attribute
* ::CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT for more information. The
* context cannot be used (and must be destroyed similar to
* ::CUDA_ERROR_LAUNCH_FAILED). All existing device memory allocations from
* this context are invalid and must be reconstructed if the program is to
* continue using CUDA.
*/
public static final int CUDA_ERROR_LAUNCH_TIMEOUT = 702;
/**
* This error indicates a kernel launch that uses an incompatible texturing
* mode.
*/
public static final int CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703;
/**
* This error indicates that a call to ::cuCtxEnablePeerAccess() is
* trying to re-enable peer access to a context which has already
* had peer access to it enabled.
*/
public static final int CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704;
/**
* This error indicates that a call to ::cuMemPeerRegister is trying to
* register memory from a context which has not had peer access
* enabled yet via ::cuCtxEnablePeerAccess(), or that
* ::cuCtxDisablePeerAccess() is trying to disable peer access
* which has not been enabled yet.
*/
public static final int CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705;
/**
* This error indicates that a call to ::cuMemPeerRegister is trying to
* register already-registered memory.
*
* @deprecated This value has been added in CUDA 4.0 RC,
* and removed in CUDA 4.0 RC2
*/
public static final int CUDA_ERROR_PEER_MEMORY_ALREADY_REGISTERED = 706;
/**
* This error indicates that a call to ::cuMemPeerUnregister is trying to
* unregister memory that has not been registered.
*
* @deprecated This value has been added in CUDA 4.0 RC,
* and removed in CUDA 4.0 RC2
*/
public static final int CUDA_ERROR_PEER_MEMORY_NOT_REGISTERED = 707;
/**
* This error indicates that ::cuCtxCreate was called with the flag
* ::CU_CTX_PRIMARY on a device which already has initialized its
* primary context.
*/
public static final int CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708;
/**
* This error indicates that the context current to the calling thread
* has been destroyed using ::cuCtxDestroy, or is a primary context which
* has not yet been initialized.
*/
public static final int CUDA_ERROR_CONTEXT_IS_DESTROYED = 709;
/**
* A device-side assert triggered during kernel execution. The context
* cannot be used anymore, and must be destroyed. All existing device
* memory allocations from this context are invalid and must be
* reconstructed if the program is to continue using CUDA.
*/
public static final int CUDA_ERROR_ASSERT = 710;
/**
* This error indicates that the hardware resources required to enable
* peer access have been exhausted for one or more of the devices
* passed to ::cuCtxEnablePeerAccess().
*/
public static final int CUDA_ERROR_TOO_MANY_PEERS = 711;
/**
* This error indicates that the memory range passed to ::cuMemHostRegister()
* has already been registered.
*/
public static final int CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712;
/**
* This error indicates that the pointer passed to ::cuMemHostUnregister()
* does not correspond to any currently registered memory region.
*/
public static final int CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713;
/**
* This error indicates that the attempted operation is not permitted.
*/
public static final int CUDA_ERROR_NOT_PERMITTED = 800;
/**
* This error indicates that the attempted operation is not supported
* on the current system or device.
*/
public static final int CUDA_ERROR_NOT_SUPPORTED = 801;
/**
* This indicates that an unknown internal error has occurred.
*/
public static final int CUDA_ERROR_UNKNOWN = 999;
/**
* Returns the String identifying the given CUresult
*
* @param result The CUresult value
* @return The String identifying the given CUresult
*/
public static String stringFor(int result) {
switch (result) {
case CUDA_SUCCESS:
return "CUDA_SUCCESS";
case CUDA_ERROR_INVALID_VALUE:
return "CUDA_ERROR_INVALID_VALUE";
case CUDA_ERROR_OUT_OF_MEMORY:
return "CUDA_ERROR_OUT_OF_MEMORY";
case CUDA_ERROR_NOT_INITIALIZED:
return "CUDA_ERROR_NOT_INITIALIZED";
case CUDA_ERROR_DEINITIALIZED:
return "CUDA_ERROR_DEINITIALIZED";
case CUDA_ERROR_PROFILER_DISABLED:
return "CUDA_ERROR_PROFILER_DISABLED";
case CUDA_ERROR_PROFILER_NOT_INITIALIZED:
return "CUDA_ERROR_PROFILER_NOT_INITIALIZED";
case CUDA_ERROR_PROFILER_ALREADY_STARTED:
return "CUDA_ERROR_PROFILER_ALREADY_STARTED";
case CUDA_ERROR_PROFILER_ALREADY_STOPPED:
return "CUDA_ERROR_PROFILER_ALREADY_STOPPED";
case CUDA_ERROR_NO_DEVICE:
return "CUDA_ERROR_NO_DEVICE";
case CUDA_ERROR_INVALID_DEVICE:
return "CUDA_ERROR_INVALID_DEVICE";
case CUDA_ERROR_INVALID_IMAGE:
return "CUDA_ERROR_INVALID_IMAGE";
case CUDA_ERROR_INVALID_CONTEXT:
return "CUDA_ERROR_INVALID_CONTEXT";
case CUDA_ERROR_CONTEXT_ALREADY_CURRENT:
return "CUDA_ERROR_CONTEXT_ALREADY_CURRENT";
case CUDA_ERROR_MAP_FAILED:
return "CUDA_ERROR_MAP_FAILED";
case CUDA_ERROR_UNMAP_FAILED:
return "CUDA_ERROR_UNMAP_FAILED";
case CUDA_ERROR_ARRAY_IS_MAPPED:
return "CUDA_ERROR_ARRAY_IS_MAPPED";
case CUDA_ERROR_ALREADY_MAPPED:
return "CUDA_ERROR_ALREADY_MAPPED";
case CUDA_ERROR_NO_BINARY_FOR_GPU:
return "CUDA_ERROR_NO_BINARY_FOR_GPU";
case CUDA_ERROR_ALREADY_ACQUIRED:
return "CUDA_ERROR_ALREADY_ACQUIRED";
case CUDA_ERROR_NOT_MAPPED:
return "CUDA_ERROR_NOT_MAPPED";
case CUDA_ERROR_NOT_MAPPED_AS_ARRAY:
return "CUDA_ERROR_NOT_MAPPED_AS_ARRAY";
case CUDA_ERROR_NOT_MAPPED_AS_POINTER:
return "CUDA_ERROR_NOT_MAPPED_AS_POINTER";
case CUDA_ERROR_ECC_UNCORRECTABLE:
return "CUDA_ERROR_ECC_UNCORRECTABLE";
case CUDA_ERROR_UNSUPPORTED_LIMIT:
return "CUDA_ERROR_UNSUPPORTED_LIMIT";
case CUDA_ERROR_CONTEXT_ALREADY_IN_USE:
return "CUDA_ERROR_CONTEXT_ALREADY_IN_USE";
case CUDA_ERROR_PEER_ACCESS_UNSUPPORTED:
return "CUDA_ERROR_PEER_ACCESS_UNSUPPORTED";
case CUDA_ERROR_INVALID_SOURCE:
return "CUDA_ERROR_INVALID_SOURCE";
case CUDA_ERROR_FILE_NOT_FOUND:
return "CUDA_ERROR_FILE_NOT_FOUND";
case CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND:
return "CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND";
case CUDA_ERROR_SHARED_OBJECT_INIT_FAILED:
return "CUDA_ERROR_SHARED_OBJECT_INIT_FAILED";
case CUDA_ERROR_OPERATING_SYSTEM:
return "CUDA_ERROR_OPERATING_SYSTEM";
case CUDA_ERROR_INVALID_HANDLE:
return "CUDA_ERROR_INVALID_HANDLE";
case CUDA_ERROR_NOT_FOUND:
return "CUDA_ERROR_NOT_FOUND";
case CUDA_ERROR_NOT_READY:
return "CUDA_ERROR_NOT_READY";
case CUDA_ERROR_LAUNCH_FAILED:
return "CUDA_ERROR_LAUNCH_FAILED";
case CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES:
return "CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES";
case CUDA_ERROR_LAUNCH_TIMEOUT:
return "CUDA_ERROR_LAUNCH_TIMEOUT";
case CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING:
return "CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING";
case CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED:
return "CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED";
case CUDA_ERROR_PEER_ACCESS_NOT_ENABLED:
return "CUDA_ERROR_PEER_ACCESS_NOT_ENABLED";
case CUDA_ERROR_PEER_MEMORY_ALREADY_REGISTERED:
return "CUDA_ERROR_PEER_MEMORY_ALREADY_REGISTERED";
case CUDA_ERROR_PEER_MEMORY_NOT_REGISTERED:
return "CUDA_ERROR_PEER_MEMORY_NOT_REGISTERED";
case CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE:
return "CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE";
case CUDA_ERROR_CONTEXT_IS_DESTROYED:
return "CUDA_ERROR_CONTEXT_IS_DESTROYED";
case CUDA_ERROR_ASSERT:
return "CUDA_ERROR_ASSERT";
case CUDA_ERROR_TOO_MANY_PEERS:
return "CUDA_ERROR_TOO_MANY_PEERS";
case CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED:
return "CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED";
case CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED:
return "CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED";
case CUDA_ERROR_NOT_PERMITTED:
return "CUDA_ERROR_NOT_PERMITTED";
case CUDA_ERROR_NOT_SUPPORTED:
return "CUDA_ERROR_NOT_SUPPORTED";
case CUDA_ERROR_UNKNOWN:
return "CUDA_ERROR_UNKNOWN";
}
return "INVALID CUresult: " + result;
}
/**
* Private constructor to prevent instantiation.
*/
private CUresult() {
}
}