Merge branch 'fix/array-vs-list' into 'master'
Fix: you can't really skip an index in an array See merge request sheepitrenderfarm/client!291
This commit is contained in:
Laurent Clouet
@@ -1,7 +1,9 @@
|
|||||||
package com.sheepit.client.hardware.gpu.nvidia;
|
package com.sheepit.client.hardware.gpu.nvidia;
|
||||||
|
|
||||||
import java.util.ArrayList;
|
import java.util.ArrayList;
|
||||||
|
import java.util.HashMap;
|
||||||
import java.util.List;
|
import java.util.List;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
import com.sheepit.client.hardware.gpu.GPUDevice;
|
import com.sheepit.client.hardware.gpu.GPUDevice;
|
||||||
import com.sheepit.client.hardware.gpu.GPULister;
|
import com.sheepit.client.hardware.gpu.GPULister;
|
||||||
@@ -18,138 +20,143 @@ public class Nvidia implements GPULister {
|
|||||||
private static final String MINIMUM_DRIVER_VERSION = "470";
|
private static final String MINIMUM_DRIVER_VERSION = "470";
|
||||||
|
|
||||||
private String getCudaErrorString(int errornum) {
|
private String getCudaErrorString(int errornum) {
|
||||||
String[] cudaerror = {};
|
Map<Integer, String> cudaerror = new HashMap<>();
|
||||||
cudaerror[0] = "cudaSuccess";
|
cudaerror.put(0, "cudaSuccess");
|
||||||
cudaerror[1] = "cudaErrorInvalidValue";
|
cudaerror.put(1, "cudaErrorInvalidValue");
|
||||||
cudaerror[2] = "cudaErrorMemoryAllocation";
|
cudaerror.put(2, "cudaErrorMemoryAllocation");
|
||||||
cudaerror[3] = "cudaErrorInitializationError";
|
cudaerror.put(3, "cudaErrorInitializationError");
|
||||||
cudaerror[4] = "cudaErrorCudartUnloading";
|
cudaerror.put(4, "cudaErrorCudartUnloading");
|
||||||
cudaerror[5] = "cudaErrorProfilerDisabled";
|
cudaerror.put(5, "cudaErrorProfilerDisabled");
|
||||||
cudaerror[6] = "cudaErrorProfilerNotInitialized";
|
cudaerror.put(6, "cudaErrorProfilerNotInitialized");
|
||||||
cudaerror[7] = "cudaErrorProfilerAlreadyStarted";
|
cudaerror.put(7, "cudaErrorProfilerAlreadyStarted");
|
||||||
cudaerror[8] = "cudaErrorProfilerAlreadyStopped";
|
cudaerror.put(8, "cudaErrorProfilerAlreadyStopped");
|
||||||
cudaerror[9] = "cudaErrorInvalidConfiguration";
|
cudaerror.put(9, "cudaErrorInvalidConfiguration");
|
||||||
cudaerror[12] = "cudaErrorInvalidPitchValue";
|
cudaerror.put(12, "cudaErrorInvalidPitchValue");
|
||||||
cudaerror[13] = "cudaErrorInvalidSymbol";
|
cudaerror.put(13, "cudaErrorInvalidSymbol");
|
||||||
cudaerror[16] = "cudaErrorInvalidHostPointer";
|
cudaerror.put(16, "cudaErrorInvalidHostPointer");
|
||||||
cudaerror[17] = "cudaErrorInvalidDevicePointer";
|
cudaerror.put(17, "cudaErrorInvalidDevicePointer");
|
||||||
cudaerror[18] = "cudaErrorInvalidTexture";
|
cudaerror.put(18, "cudaErrorInvalidTexture");
|
||||||
cudaerror[19] = "cudaErrorInvalidTextureBinding";
|
cudaerror.put(19, "cudaErrorInvalidTextureBinding");
|
||||||
cudaerror[20] = "cudaErrorInvalidChannelDescriptor";
|
cudaerror.put(20, "cudaErrorInvalidChannelDescriptor");
|
||||||
cudaerror[21] = "cudaErrorInvalidMemcpyDirection";
|
cudaerror.put(21, "cudaErrorInvalidMemcpyDirection");
|
||||||
cudaerror[22] = "cudaErrorAddressOfConstant";
|
cudaerror.put(22, "cudaErrorAddressOfConstant");
|
||||||
cudaerror[23] = "cudaErrorTextureFetchFailed";
|
cudaerror.put(23, "cudaErrorTextureFetchFailed");
|
||||||
cudaerror[24] = "cudaErrorTextureNotBound";
|
cudaerror.put(24, "cudaErrorTextureNotBound");
|
||||||
cudaerror[25] = "cudaErrorSynchronizationError";
|
cudaerror.put(25, "cudaErrorSynchronizationError");
|
||||||
cudaerror[26] = "cudaErrorInvalidFilterSetting";
|
cudaerror.put(26, "cudaErrorInvalidFilterSetting");
|
||||||
cudaerror[27] = "cudaErrorInvalidNormSetting";
|
cudaerror.put(27, "cudaErrorInvalidNormSetting");
|
||||||
cudaerror[28] = "cudaErrorMixedDeviceExecution";
|
cudaerror.put(28, "cudaErrorMixedDeviceExecution");
|
||||||
cudaerror[31] = "cudaErrorNotYetImplemented";
|
cudaerror.put(31, "cudaErrorNotYetImplemented");
|
||||||
cudaerror[32] = "cudaErrorMemoryValueTooLarge";
|
cudaerror.put(32, "cudaErrorMemoryValueTooLarge");
|
||||||
cudaerror[34] = "cudaErrorStubLibrary";
|
cudaerror.put(34, "cudaErrorStubLibrary");
|
||||||
cudaerror[35] = "cudaErrorInsufficientDriver";
|
cudaerror.put(35, "cudaErrorInsufficientDriver");
|
||||||
cudaerror[36] = "cudaErrorCallRequiresNewerDriver";
|
cudaerror.put(36, "cudaErrorCallRequiresNewerDriver");
|
||||||
cudaerror[37] = "cudaErrorInvalidSurface";
|
cudaerror.put(37, "cudaErrorInvalidSurface");
|
||||||
cudaerror[43] = "cudaErrorDuplicateVariableName";
|
cudaerror.put(43, "cudaErrorDuplicateVariableName");
|
||||||
cudaerror[44] = "cudaErrorDuplicateTextureName";
|
cudaerror.put(44, "cudaErrorDuplicateTextureName");
|
||||||
cudaerror[45] = "cudaErrorDuplicateSurfaceName";
|
cudaerror.put(45, "cudaErrorDuplicateSurfaceName");
|
||||||
cudaerror[46] = "cudaErrorDevicesUnavailable";
|
cudaerror.put(46, "cudaErrorDevicesUnavailable");
|
||||||
cudaerror[49] = "cudaErrorIncompatibleDriverContext";
|
cudaerror.put(49, "cudaErrorIncompatibleDriverContext");
|
||||||
cudaerror[52] = "cudaErrorMissingConfiguration";
|
cudaerror.put(52, "cudaErrorMissingConfiguration");
|
||||||
cudaerror[53] = "cudaErrorPriorLaunchFailure";
|
cudaerror.put(53, "cudaErrorPriorLaunchFailure");
|
||||||
cudaerror[65] = "cudaErrorLaunchMaxDepthExceeded";
|
cudaerror.put(65, "cudaErrorLaunchMaxDepthExceeded");
|
||||||
cudaerror[66] = "cudaErrorLaunchFileScopedTex";
|
cudaerror.put(66, "cudaErrorLaunchFileScopedTex");
|
||||||
cudaerror[67] = "cudaErrorLaunchFileScopedSurf";
|
cudaerror.put(67, "cudaErrorLaunchFileScopedSurf");
|
||||||
cudaerror[68] = "cudaErrorSyncDepthExceeded";
|
cudaerror.put(68, "cudaErrorSyncDepthExceeded");
|
||||||
cudaerror[69] = "cudaErrorLaunchPendingCountExceeded";
|
cudaerror.put(69, "cudaErrorLaunchPendingCountExceeded");
|
||||||
cudaerror[98] = "cudaErrorInvalidDeviceFunction";
|
cudaerror.put(98, "cudaErrorInvalidDeviceFunction");
|
||||||
cudaerror[100] = "cudaErrorNoDevice";
|
cudaerror.put(100, "cudaErrorNoDevice");
|
||||||
cudaerror[101] = "cudaErrorInvalidDevice";
|
cudaerror.put(101, "cudaErrorInvalidDevice");
|
||||||
cudaerror[102] = "cudaErrorDeviceNotLicensed";
|
cudaerror.put(102, "cudaErrorDeviceNotLicensed");
|
||||||
cudaerror[103] = "cudaErrorSoftwareValidityNotEstablished";
|
cudaerror.put(103, "cudaErrorSoftwareValidityNotEstablished");
|
||||||
cudaerror[127] = "cudaErrorStartupFailure";
|
cudaerror.put(127, "cudaErrorStartupFailure");
|
||||||
cudaerror[200] = "cudaErrorInvalidKernelImage";
|
cudaerror.put(200, "cudaErrorInvalidKernelImage");
|
||||||
cudaerror[201] = "cudaErrorDeviceUninitialized";
|
cudaerror.put(201, "cudaErrorDeviceUninitialized");
|
||||||
cudaerror[205] = "cudaErrorMapBufferObjectFailed";
|
cudaerror.put(205, "cudaErrorMapBufferObjectFailed");
|
||||||
cudaerror[206] = "cudaErrorUnmapBufferObjectFailed";
|
cudaerror.put(206, "cudaErrorUnmapBufferObjectFailed");
|
||||||
cudaerror[207] = "cudaErrorArrayIsMapped";
|
cudaerror.put(207, "cudaErrorArrayIsMapped");
|
||||||
cudaerror[208] = "cudaErrorAlreadyMapped";
|
cudaerror.put(208, "cudaErrorAlreadyMapped");
|
||||||
cudaerror[209] = "cudaErrorNoKernelImageForDevice";
|
cudaerror.put(209, "cudaErrorNoKernelImageForDevice");
|
||||||
cudaerror[210] = "cudaErrorAlreadyAcquired";
|
cudaerror.put(210, "cudaErrorAlreadyAcquired");
|
||||||
cudaerror[211] = "cudaErrorNotMapped";
|
cudaerror.put(211, "cudaErrorNotMapped");
|
||||||
cudaerror[212] = "cudaErrorNotMappedAsArray";
|
cudaerror.put(212, "cudaErrorNotMappedAsArray");
|
||||||
cudaerror[213] = "cudaErrorNotMappedAsPointer";
|
cudaerror.put(213, "cudaErrorNotMappedAsPointer");
|
||||||
cudaerror[214] = "cudaErrorECCUncorrectable";
|
cudaerror.put(214, "cudaErrorECCUncorrectable");
|
||||||
cudaerror[215] = "cudaErrorUnsupportedLimit";
|
cudaerror.put(215, "cudaErrorUnsupportedLimit");
|
||||||
cudaerror[216] = "cudaErrorDeviceAlreadyInUse";
|
cudaerror.put(216, "cudaErrorDeviceAlreadyInUse");
|
||||||
cudaerror[217] = "cudaErrorPeerAccessUnsupported";
|
cudaerror.put(217, "cudaErrorPeerAccessUnsupported");
|
||||||
cudaerror[218] = "cudaErrorInvalidPtx";
|
cudaerror.put(218, "cudaErrorInvalidPtx");
|
||||||
cudaerror[219] = "cudaErrorInvalidGraphicsContext";
|
cudaerror.put(219, "cudaErrorInvalidGraphicsContext");
|
||||||
cudaerror[220] = "cudaErrorNvlinkUncorrectable";
|
cudaerror.put(220, "cudaErrorNvlinkUncorrectable");
|
||||||
cudaerror[221] = "cudaErrorJitCompilerNotFound";
|
cudaerror.put(221, "cudaErrorJitCompilerNotFound");
|
||||||
cudaerror[222] = "cudaErrorUnsupportedPtxVersion";
|
cudaerror.put(222, "cudaErrorUnsupportedPtxVersion");
|
||||||
cudaerror[223] = "cudaErrorJitCompilationDisabled";
|
cudaerror.put(223, "cudaErrorJitCompilationDisabled");
|
||||||
cudaerror[224] = "cudaErrorUnsupportedExecAffinity";
|
cudaerror.put(224, "cudaErrorUnsupportedExecAffinity");
|
||||||
cudaerror[225] = "cudaErrorUnsupportedDevSideSync";
|
cudaerror.put(225, "cudaErrorUnsupportedDevSideSync");
|
||||||
cudaerror[300] = "cudaErrorInvalidSource";
|
cudaerror.put(300, "cudaErrorInvalidSource");
|
||||||
cudaerror[301] = "cudaErrorFileNotFound";
|
cudaerror.put(301, "cudaErrorFileNotFound");
|
||||||
cudaerror[302] = "cudaErrorSharedObjectSymbolNotFound";
|
cudaerror.put(302, "cudaErrorSharedObjectSymbolNotFound");
|
||||||
cudaerror[303] = "cudaErrorSharedObjectInitFailed";
|
cudaerror.put(303, "cudaErrorSharedObjectInitFailed");
|
||||||
cudaerror[304] = "cudaErrorOperatingSystem";
|
cudaerror.put(304, "cudaErrorOperatingSystem");
|
||||||
cudaerror[400] = "cudaErrorInvalidResourceHandle";
|
cudaerror.put(400, "cudaErrorInvalidResourceHandle");
|
||||||
cudaerror[401] = "cudaErrorIllegalState";
|
cudaerror.put(401, "cudaErrorIllegalState");
|
||||||
cudaerror[402] = "cudaErrorLossyQuery";
|
cudaerror.put(402, "cudaErrorLossyQuery");
|
||||||
cudaerror[500] = "cudaErrorSymbolNotFound";
|
cudaerror.put(500, "cudaErrorSymbolNotFound");
|
||||||
cudaerror[600] = "cudaErrorNotReady";
|
cudaerror.put(600, "cudaErrorNotReady");
|
||||||
cudaerror[700] = "cudaErrorIllegalAddress";
|
cudaerror.put(700, "cudaErrorIllegalAddress");
|
||||||
cudaerror[701] = "cudaErrorLaunchOutOfResources";
|
cudaerror.put(701, "cudaErrorLaunchOutOfResources");
|
||||||
cudaerror[702] = "cudaErrorLaunchTimeout";
|
cudaerror.put(702, "cudaErrorLaunchTimeout");
|
||||||
cudaerror[703] = "cudaErrorLaunchIncompatibleTexturing";
|
cudaerror.put(703, "cudaErrorLaunchIncompatibleTexturing");
|
||||||
cudaerror[704] = "cudaErrorPeerAccessAlreadyEnabled";
|
cudaerror.put(704, "cudaErrorPeerAccessAlreadyEnabled");
|
||||||
cudaerror[705] = "cudaErrorPeerAccessNotEnabled";
|
cudaerror.put(705, "cudaErrorPeerAccessNotEnabled");
|
||||||
cudaerror[708] = "cudaErrorSetOnActiveProcess";
|
cudaerror.put(708, "cudaErrorSetOnActiveProcess");
|
||||||
cudaerror[709] = "cudaErrorContextIsDestroyed";
|
cudaerror.put(709, "cudaErrorContextIsDestroyed");
|
||||||
cudaerror[710] = "cudaErrorAssert";
|
cudaerror.put(710, "cudaErrorAssert");
|
||||||
cudaerror[711] = "cudaErrorTooManyPeers";
|
cudaerror.put(711, "cudaErrorTooManyPeers");
|
||||||
cudaerror[712] = "cudaErrorHostMemoryAlreadyRegistered";
|
cudaerror.put(712, "cudaErrorHostMemoryAlreadyRegistered");
|
||||||
cudaerror[713] = "cudaErrorHostMemoryNotRegistered";
|
cudaerror.put(713, "cudaErrorHostMemoryNotRegistered");
|
||||||
cudaerror[714] = "cudaErrorHardwareStackError";
|
cudaerror.put(714, "cudaErrorHardwareStackError");
|
||||||
cudaerror[715] = "cudaErrorIllegalInstruction";
|
cudaerror.put(715, "cudaErrorIllegalInstruction");
|
||||||
cudaerror[716] = "cudaErrorMisalignedAddress";
|
cudaerror.put(716, "cudaErrorMisalignedAddress");
|
||||||
cudaerror[717] = "cudaErrorInvalidAddressSpace";
|
cudaerror.put(717, "cudaErrorInvalidAddressSpace");
|
||||||
cudaerror[718] = "cudaErrorInvalidPc";
|
cudaerror.put(718, "cudaErrorInvalidPc");
|
||||||
cudaerror[719] = "cudaErrorLaunchFailure";
|
cudaerror.put(719, "cudaErrorLaunchFailure");
|
||||||
cudaerror[720] = "cudaErrorCooperativeLaunchTooLarge";
|
cudaerror.put(720, "cudaErrorCooperativeLaunchTooLarge");
|
||||||
cudaerror[800] = "cudaErrorNotPermitted";
|
cudaerror.put(800, "cudaErrorNotPermitted");
|
||||||
cudaerror[801] = "cudaErrorNotSupported";
|
cudaerror.put(801, "cudaErrorNotSupported");
|
||||||
cudaerror[802] = "cudaErrorSystemNotReady";
|
cudaerror.put(802, "cudaErrorSystemNotReady");
|
||||||
cudaerror[803] = "cudaErrorSystemDriverMismatch";
|
cudaerror.put(803, "cudaErrorSystemDriverMismatch");
|
||||||
cudaerror[804] = "cudaErrorCompatNotSupportedOnDevice";
|
cudaerror.put(804, "cudaErrorCompatNotSupportedOnDevice");
|
||||||
cudaerror[805] = "cudaErrorMpsConnectionFailed";
|
cudaerror.put(805, "cudaErrorMpsConnectionFailed");
|
||||||
cudaerror[806] = "cudaErrorMpsRpcFailure";
|
cudaerror.put(806, "cudaErrorMpsRpcFailure");
|
||||||
cudaerror[807] = "cudaErrorMpsServerNotReady";
|
cudaerror.put(807, "cudaErrorMpsServerNotReady");
|
||||||
cudaerror[808] = "cudaErrorMpsMaxClientsReached";
|
cudaerror.put(808, "cudaErrorMpsMaxClientsReached");
|
||||||
cudaerror[809] = "cudaErrorMpsMaxConnectionsReached";
|
cudaerror.put(809, "cudaErrorMpsMaxConnectionsReached");
|
||||||
cudaerror[810] = "cudaErrorMpsClientTerminated";
|
cudaerror.put(810, "cudaErrorMpsClientTerminated");
|
||||||
cudaerror[811] = "cudaErrorCdpNotSupported";
|
cudaerror.put(811, "cudaErrorCdpNotSupported");
|
||||||
cudaerror[812] = "cudaErrorCdpVersionMismatch";
|
cudaerror.put(812, "cudaErrorCdpVersionMismatch");
|
||||||
cudaerror[900] = "cudaErrorStreamCaptureUnsupported";
|
cudaerror.put(900, "cudaErrorStreamCaptureUnsupported");
|
||||||
cudaerror[901] = "cudaErrorStreamCaptureInvalidated";
|
cudaerror.put(901, "cudaErrorStreamCaptureInvalidated");
|
||||||
cudaerror[902] = "cudaErrorStreamCaptureMerge";
|
cudaerror.put(902, "cudaErrorStreamCaptureMerge");
|
||||||
cudaerror[903] = "cudaErrorStreamCaptureUnmatched";
|
cudaerror.put(903, "cudaErrorStreamCaptureUnmatched");
|
||||||
cudaerror[904] = "cudaErrorStreamCaptureUnjoined";
|
cudaerror.put(904, "cudaErrorStreamCaptureUnjoined");
|
||||||
cudaerror[905] = "cudaErrorStreamCaptureIsolation";
|
cudaerror.put(905, "cudaErrorStreamCaptureIsolation");
|
||||||
cudaerror[906] = "cudaErrorStreamCaptureImplicit";
|
cudaerror.put(906, "cudaErrorStreamCaptureImplicit");
|
||||||
cudaerror[907] = "cudaErrorCapturedEvent";
|
cudaerror.put(907, "cudaErrorCapturedEvent");
|
||||||
cudaerror[908] = "cudaErrorStreamCaptureWrongThread";
|
cudaerror.put(908, "cudaErrorStreamCaptureWrongThread");
|
||||||
cudaerror[909] = "cudaErrorTimeout";
|
cudaerror.put(909, "cudaErrorTimeout");
|
||||||
cudaerror[910] = "cudaErrorGraphExecUpdateFailure";
|
cudaerror.put(910, "cudaErrorGraphExecUpdateFailure");
|
||||||
cudaerror[911] = "cudaErrorExternalDevice";
|
cudaerror.put(911, "cudaErrorExternalDevice");
|
||||||
cudaerror[912] = "cudaErrorInvalidClusterSize";
|
cudaerror.put(912, "cudaErrorInvalidClusterSize");
|
||||||
cudaerror[999] = "cudaErrorUnknown";
|
cudaerror.put(999, "cudaErrorUnknown");
|
||||||
cudaerror[10000] = "cudaErrorApiFailureBase";
|
cudaerror.put(10000, "cudaErrorApiFailureBase");
|
||||||
|
|
||||||
return cudaerror[errornum];
|
if (cudaerror.containsKey(errornum)) {
|
||||||
|
return cudaerror.get(errornum);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
return "Unknown(" + errornum + ")";
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override public List<GPUDevice> getGpus() {
|
@Override public List<GPUDevice> getGpus() {
|
||||||
|
|||||||
Reference in New Issue
Block a user