`iV SSK7 SSKJr SSKrSSKrSSKrSSKrSSKJr \rSr Sr "SS\5r \r Sr SrSrS rS rS rS rS r"SS\5r\rSrSrSrS rS r"SS\5r\rSrSr"SS\5r \r!Sr"Sr#Sr$S r%S r&"SS\5r'\r(Sr)Sr*Sr+Sr,S r-S r.S r/S r0S r1Sr2"SS\5r3\r4Sr5Sr6Sr7\r8Sr9Sr:Sr;"SS\5r<\r=Sr>Sr?Sr@"SS\5rA\rBSrCSrDSrES rFS rG"SS\5rH\rISrJSrK"SS \5rL\rMSrNSrOSrPS rQS rRS rSS rTS rUSrVS!rWS"rXS#rYS$rZS%r[S&r\S'r]S(r^"S)S*\5r_\r`SraSrbSrcS rd"S+S,\5re\rfSrgSrhSriS rjS rkS rlS rmS rnSroS!rpS"rqS#rrS$rsS%rtS&ruS'rvS-rwS.rxS/ryS0rzS1r{S2r|S3r}S4r~"S5S6\5r\rSrSr"S7S8\5r\rSrSr"S9S:\5r\rSrSrSr"S;S<\5r\rSrSrSr"S=S>\5r\rSrSrSr"S?S@\5r\rSrSrSAr"SBSC\5r\rSrSrSrS rS rS r"SDSE\5r\rSrSrSrS rS rS rS"rS#rS$r"SFSG\5r\rSrSrSrS rS rS rS rS r"SHSI\5r\rSrSrSr"SJSK\5r\rSrS"rS1rSLrSMrSNr"SOSP\5rSrSrS-rSQrSRrSQrSSrSLrS(rS-r\"ST5r\"ST5rSq\GR"5rSq"SUSV\5rSWr\"5 SXr\"5rSYr"SZS[\5rS\rS]r"S^S_\5r\"\5rS`r"SaSb\5r"ScSd\5r"SeSf\5r"SgSh\5r"SiSj\5r"SkSl\5r"SmSn\5r\"\5r"SoSp\5r"SqSr\5r"SsSt\5r"SuSv\5r"SwSx\5r"SySz\5r"S{S|\5r"S}S~\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r\"\5rSrSrS GrSGrS-GrSGrG\\-\-G\-G\-G\-GrSGrSGrG\GrS GrSGr SGr SGr G\ G\-G\-G\-G\ -G\ -Gr "SS\5Gr "SS\5GrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGrSGr SGr!SGr"SGr#SGr$SGr%SGr&SGr'SGr(SGr)SGr*SGr+SGr,SGr-SGr.SGr/SGr0SGr1SGr2SGr3SGr4SGr5SGr6SGr7SGr8SGr9SGr:SGr;SGrSGr?SGr@SGrASGrBSGrCSGrDSGrESGrFSGrGSGrHSGrISGrJSGrKSGrLSGrMSGrNSGrOSGrPSGrQSGrRSGrSSGrTSGrUSGrVSGrWSGrXSGrYSGrZSGr[SGr\SGr]SGr^SGr_SGr`SGraSGrbSGrcSGrdSGreSGrfSGrgSGrhSGriSGrjSGrkSGrlSGrmSGrnSGroSGrpSGrqSGrrSGrsSGrtSGruSGrvSGrwSGrxSGrySGrzSGr{SGr|SGr}SGr~SGrSGrGSGrGSGrGSGrGSGrGSGrGSGrGSGrGSGrGSGrg( )*)c_uintN)Enumc\rSrSrSrSrSrg)nvmlEnableState_t-rrN)__name__ __module__ __qualname____firstlineno__NVML_FEATURE_DISABLEDNVML_FEATURE_ENABLED__static_attributes__r N/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/py3nvml/py3nvml.pyrr-srrc4\rSrSrSrSrSrSrSrSr Sr S r S r g ) nvmlBrandType_t;rrrrrrrrr N) r r r rNVML_BRAND_UNKNOWNNVML_BRAND_QUADRONVML_BRAND_TESLANVML_BRAND_NVSNVML_BRAND_GRIDNVML_BRAND_GEFORCENVML_BRAND_TITANNVML_BRAND_COUNTrr rrrr;s0NOrrc,\rSrSrSrSrSrSrSrSr Sr g ) nvmlTemperatureThresholds_tLa // Temperature at which the GPU will shut down for HW protection NVML_TEMPERATURE_THRESHOLD_SHUTDOWN = 0, // Temperature at which the GPU will begin HW slowdown NVML_TEMPERATURE_THRESHOLD_SLOWDOWN = 1, // Memory Temperature at which the GPU will begin SW slowdown NVML_TEMPERATURE_THRESHOLD_MEM_MAX = 2, // GPU Temperature at which the GPU can be throttled below base clock NVML_TEMPERATURE_THRESHOLD_GPU_MAX = 3, rrrrrr N) r r r r__doc__#NVML_TEMPERATURE_THRESHOLD_SHUTDOWN#NVML_TEMPERATURE_THRESHOLD_SLOWDOWN"NVML_TEMPERATURE_THRESHOLD_MEM_MAX"NVML_TEMPERATURE_THRESHOLD_GPU_MAX NVML_TEMPERATURE_THRESHOLD_COUNTrr rrr&r&Ls' +,'*+')*&)*&'($rr&c \rSrSrSrSrSrSrg)nvmlTemperatureSensors_tazK NVML_TEMPERATURE_GPU = 0, //!< Temperature sensor for the GPU die rrr N)r r r rr(NVML_TEMPERATURE_GPUNVML_TEMPERATURE_COUNTrr rrr/r/asrr/c(\rSrSrSrSrSrSrSrSr g) nvmlComputeMode_trrrrrrr N) r r r rNVML_COMPUTEMODE_DEFAULT!NVML_COMPUTEMODE_EXCLUSIVE_THREADNVML_COMPUTEMODE_PROHIBITED"NVML_COMPUTEMODE_EXCLUSIVE_PROCESSNVML_COMPUTEMODE_COUNTrr rrr4r4rs  ()%"#)*&rr4c<\rSrSrSrSrSrSrSrSr Sr Sr S r S r S rg ) nvmlMemoryLocation_trrrrrrrrr;r N)r r r rNVML_MEMORY_LOCATION_L1_CACHENVML_MEMORY_LOCATION_L2_CACHENVML_MEMORY_LOCATION_DRAM"NVML_MEMORY_LOCATION_DEVICE_MEMORY"NVML_MEMORY_LOCATION_REGISTER_FILE#NVML_MEMORY_LOCATION_TEXTURE_MEMORY NVML_MEMORY_LOCATION_TEXTURE_SHMNVML_MEMORY_LOCATION_CBUNVML_MEMORY_LOCATION_SRAMNVML_MEMORY_LOCATION_COUNTrr rrr=r=s>$%!$%! !)*&)*&*+''($  !!"rr=c$\rSrSrSrSrSrSrSrg)nvmlEccCounterType_tz // Volatile counts are reset each time the driver loads. NVML_VOLATILE_ECC = 0, // Aggregate counts persist across reboots (i.e. for the lifetime of the // device) NVML_AGGREGATE_ECC = 1, rrrr N) r r r rr(NVML_VOLATILE_ECCNVML_AGGREGATE_ECCNVML_ECC_COUNTER_TYPE_COUNTrr rrrJrJs"#rrJc$\rSrSrSrSrSrSrSrg)nvmlMemoryErrorType_ta /** * A memory error that was corrected * * For ECC errors, these are single bit errors * For Texture memory, these are errors fixed by resend */ NVML_MEMORY_ERROR_TYPE_CORRECTED = 0, /** * A memory error that was not corrected * * For ECC errors, these are double bit errors * For Texture memory, these are errors where the resend fails */ NVML_MEMORY_ERROR_TYPE_UNCORRECTED = 1, rrrr N) r r r rr( NVML_MEMORY_ERROR_TYPE_CORRECTED"NVML_MEMORY_ERROR_TYPE_UNCORRECTEDNVML_MEMORY_ERROR_TYPE_COUNTrr rrrPrPs ()$)*&#$ rrPc(\rSrSrSrSrSrSrSrSr g) nvmlClockType_trrrrrr N) r r r rNVML_CLOCK_GRAPHICS NVML_CLOCK_SMNVML_CLOCK_MEMNVML_CLOCK_VIDEONVML_CLOCK_COUNTrr rrrVrVsMNrrVc \rSrSrSrSrSrSrg)nvmlDriverModel_tz // WDDM driver model -- GPU treated as a display device NVML_DRIVER_WDDM = 0, // WDM (TCC) model (recommended) -- GPU treated as a generic device NVML_DRIVER_WDM = 1 rrr N)r r r rr(NVML_DRIVER_WDDMNVML_DRIVER_WDMrr rrr^r^s Orr^  c\\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrg) nvmlPstates_tzJ Performance State 0 is maximum performance and 15 is minimum performance rrrrrrrrr;rbrcrdrerfrgrhrir N)r r r rr( NVML_PSTATE_0 NVML_PSTATE_1 NVML_PSTATE_2 NVML_PSTATE_3 NVML_PSTATE_4 NVML_PSTATE_5 NVML_PSTATE_6 NVML_PSTATE_7 NVML_PSTATE_8 NVML_PSTATE_9NVML_PSTATE_10NVML_PSTATE_11NVML_PSTATE_12NVML_PSTATE_13NVML_PSTATE_14NVML_PSTATE_15NVML_PSTATE_UNKNOWNrr rrrkrks_MMMMMMMMMMNNNNNNrrkc(\rSrSrSrSrSrSrSrSr g) nvmlInforomObject_ti z // An object defined by OEM NVML_INFOROM_OEM = 0, // The ECC object determining the level of ECC support NVML_INFOROM_ECC = 1, // The power management object NVML_INFOROM_POWER = 2, rrrrr N) r r r rr(NVML_INFOROM_OEMNVML_INFOROM_ECCNVML_INFOROM_POWERNVML_INFOROM_COUNTrr rrrr s!rrcx\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrg) nvmlReturn_ti4a // The operation was successful NVML_SUCCESS = 0, // NVML was not first initialized with nvmlInit() NVML_ERROR_UNINITIALIZED = 1, // A supplied argument is invalid NVML_ERROR_INVALID_ARGUMENT = 2, // The requested operation is not available on target device NVML_ERROR_NOT_SUPPORTED = 3, // The current user does not have permission for operation NVML_ERROR_NO_PERMISSION = 4, // Deprecated: Multiple initializations are now allowed through ref counting NVML_ERROR_ALREADY_INITIALIZED = 5, // A query to find an object was unsuccessful NVML_ERROR_NOT_FOUND = 6, // An input argument is not large enough NVML_ERROR_INSUFFICIENT_SIZE = 7, //A device's external power cables are not properly attached NVML_ERROR_INSUFFICIENT_POWER = 8, // NVIDIA driver is not loaded NVML_ERROR_DRIVER_NOT_LOADED = 9, // User provided timeout passed NVML_ERROR_TIMEOUT = 10, // NVIDIA Kernel detected an interrupt issue with a GPU NVML_ERROR_IRQ_ISSUE = 11, // NVML Shared Library couldn't be found or loaded NVML_ERROR_LIBRARY_NOT_FOUND = 12, // Local version of NVML doesn't implement this function NVML_ERROR_FUNCTION_NOT_FOUND = 13, // infoROM is corrupted NVML_ERROR_CORRUPTED_INFOROM = 14, // The GPU has fallen off the bus or has otherwise become inaccessible NVML_ERROR_GPU_IS_LOST = 15, // The GPU requires a reset before it can be used again NVML_ERROR_RESET_REQUIRED = 16, // The GPU control device has been blocked by the operating system/cgroups NVML_ERROR_OPERATING_SYSTEM = 17, // RM detects a driver/library version mismatch NVML_ERROR_LIB_RM_VERSION_MISMATCH = 18, // An operation cannot be performed because the GPU is currently in use NVML_ERROR_IN_USE = 19, // Insufficient memory NVML_ERROR_MEMORY = 20, // No data NVML_ERROR_NO_DATA = 21, // The requested vgpu operation is not available on target device, becasue // ECC is enabled NVML_ERROR_VGPU_ECC_NOT_SUPPORTED = 22, // An internal driver error occurred NVML_ERROR_UNKNOWN = 999 rrrrrrrrr;rbrcrdrerfrgrhrrrrrrrrr N)r r r rr( NVML_SUCCESSNVML_ERROR_UNINITIALIZEDNVML_ERROR_INVALID_ARGUMENTNVML_ERROR_NOT_SUPPORTEDNVML_ERROR_NO_PERMISSIONNVML_ERROR_ALREADY_INITIALIZEDNVML_ERROR_NOT_FOUNDNVML_ERROR_INSUFFICIENT_SIZENVML_ERROR_INSUFFICIENT_POWERNVML_ERROR_DRIVER_NOT_LOADEDNVML_ERROR_TIMEOUTNVML_ERROR_IRQ_ISSUENVML_ERROR_LIBRARY_NOT_FOUNDNVML_ERROR_FUNCTION_NOT_FOUNDNVML_ERROR_CORRUPTED_INFOROMNVML_ERROR_GPU_IS_LOSTNVML_ERROR_RESET_REQUIREDNVML_ERROR_OPERATING_SYSTEM"NVML_ERROR_LIB_RM_VERSION_MISMATCHNVML_ERROR_IN_USENVML_ERROR_MEMORYNVML_ERROR_NO_DATA!NVML_ERROR_VGPU_ECC_NOT_SUPPORTEDNVML_ERROR_UNKNOWNrr rrrr4s2fL "#  %&"#$ $%!#$ #% $&!#%  ""$)+&(*%rrc \rSrSrSrSrSrSrg) nvmlFanStateizp NVML_FAN_NORMAL = 0, //!< Fan is working properly NVML_FAN_FAILED = 1 //!< Fan has failed rrr N)r r r rr(NVML_FAN_NORMALNVML_FAN_FAILEDrr rrrrsOOrrc \rSrSrSrSrSrSrg) nvmlLedColoriz NVML_LED_COLOR_GREEN = 0, //!< GREEN, indicates good health NVML_LED_COLOR_AMBER = 1 //!< AMBER, indicates problem rrr N)r r r rr(NVML_LED_COLOR_GREENNVML_LED_COLOR_AMBERrr rrrrsrrc$\rSrSrSrSrSrSrSrg)nvmlGpuOperationModeia // Everything is enabled and running at full speed NVML_GOM_ALL_ON = 0 // Designed for running only compute tasks. Graphics operations are not // allowed NVML_GOM_COMPUTE = 1 // Designed for running graphics applications that don't require NVML_GOM_LOW_DP = 2 rrrr N) r r r rr(NVML_GOM_ALL_ONNVML_GOM_COMPUTENVML_GOM_LOW_DPrr rrrrsOOrrc$\rSrSrSrSrSrSrSrg)nvmlPageRetirementCause_tiz // Page was retired due to multiple single bit ECC error NVML_PAGE_RETIREMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS = 0, // Page was retired due to double bit ECC error NVML_PAGE_RETIREMENT_CAUSE_DOUBLE_BIT_ECC_ERROR = 1, rrrr N) r r r rr(/NVML_PAGE_RETIREMENT_CAUSE_DOUBLE_BIT_ECC_ERROR9NVML_PAGE_RETIREMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS NVML_PAGE_RETIREMENT_CAUSE_COUNTrr rrrrs 783@A='($rrc$\rSrSrSrSrSrSrSrg)nvmlRestrictedAPI_tia; // APIs that change application clocks, see // nvmlDeviceSetApplicationsClocks and see // nvmlDeviceResetApplicationsClocks NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS = 0, // APIs that enable/disable Auto Boosted clocks // see nvmlDeviceSetAutoBoostedClocksEnabled NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKS = 1, rrrr N) r r r rr(*NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS+NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKSNVML_RESTRICTED_API_COUNTrr rrrrs23.23/ !rrc \rSrSrSrSrSrSrg)nvmlBridgeChipType_tirrrr N)r r r rNVML_BRIDGE_CHIP_PLXNVML_BRIDGE_CHIP_BRO4NVML_MAX_PHYSICAL_BRIDGErr rrrrs"rrc,\rSrSrSrSrSrSrSrSr Sr g ) nvmlValueType_tirrrrrrr N) r r r rNVML_VALUE_TYPE_DOUBLENVML_VALUE_TYPE_UNSIGNED_INTNVML_VALUE_TYPE_UNSIGNED_LONG"NVML_VALUE_TYPE_UNSIGNED_LONG_LONG NVML_VALUE_TYPE_SIGNED_LONG_LONGNVML_VALUE_TYPE_COUNTrr rrrrs&#$ $%!)*&'($rrc<\rSrSrSrSrSrSrSrSr Sr S r S r S r S rg )nvmlPerfPolicyType_tia // How long did power violations cause the GPU to be below application // clocks NVML_PERF_POLICY_POWER = 0, // How long did thermal violations cause the GPU to be below application // clocks NVML_PERF_POLICY_THERMAL = 1, // How long did sync boost cause the GPU to be below application clocks NVML_PERF_POLICY_SYNC_BOOST = 2, // How long did the board limit cause the GPU to be below application clocks NVML_PERF_POLICY_BOARD_LIMIT = 3, // How long did low utilization cause the GPU to be below application clocks NVML_PERF_POLICY_LOW_UTILIZATION = 4, // How long did the board reliability limit cause the GPU to be below // application clocks NVML_PERF_POLICY_RELIABILITY = 5, // Total time the GPU was held below application clocks by any limiter // (0 - 5 above) NVML_PERF_POLICY_TOTAL_APP_CLOCKS = 10, // Total time the GPU was held below base clocks NVML_PERF_POLICY_TOTAL_BASE_CLOCKS = 11, rrrrrrrcrdrer N)r r r rr(NVML_PERF_POLICY_POWERNVML_PERF_POLICY_THERMALNVML_PERF_POLICY_SYNC_BOOSTNVML_PERF_POLICY_BOARD_LIMIT NVML_PERF_POLICY_LOW_UTILIZATIONNVML_PERF_POLICY_RELIABILITY!NVML_PERF_POLICY_TOTAL_APP_CLOCKS"NVML_PERF_POLICY_TOTAL_BASE_CLOCKSNVML_PERF_POLICY_COUNTrr rrrrs?, "##$ '($#$ (*%)+&rrc8\rSrSrSrSrSrSrSrSr Sr S r S r S r g ) nvmlSamplingType_tia // To represent total power drawn by GPU NVML_TOTAL_POWER_SAMPLES = 0, // To represent percent of time during which one or more kernels was // executing on the GPU NVML_GPU_UTILIZATION_SAMPLES = 1, // To represent percent of time during which global (device) memory was // being read or written NVML_MEMORY_UTILIZATION_SAMPLES = 2, // To represent percent of time during which NVENC remains busy NVML_ENC_UTILIZATION_SAMPLES = 3, // To represent percent of time during which NVDEC remains busy NVML_DEC_UTILIZATION_SAMPLES = 4, // To represent processor clock samples NVML_PROCESSOR_CLK_SAMPLES = 5, // To represent memory clock samples NVML_MEMORY_CLK_SAMPLES = 6, rrrrrrrrr N)r r r rr(NVML_TOTAL_POWER_SAMPLESNVML_GPU_UTILIZATION_SAMPLESNVML_MEMORY_UTILIZATION_SAMPLESNVML_ENC_UTILIZATION_SAMPLESNVML_DEC_UTILIZATION_SAMPLESNVML_PROCESSOR_CLK_SAMPLESNVML_MEMORY_CLK_SAMPLESNVML_SAMPLINGTYPE_COUNTrr rrrrs9$ !#$ &'##$ #$ !"rrc$\rSrSrSrSrSrSrSrg)nvmlPcieUtilCouter_ti:zy NVML_PCIE_UTIL_TX_BYTES = 0, // 1KB granularity NVML_PCIE_UTIL_RX_BYTES = 1, // 1KB granularity rrrr N) r r r rr(NVML_PCIE_UTIL_TX_BYTESNVML_PCIE_UTIL_RX_BYTESNVML_PCIE_UTIL_COUNTrr rrrr:s rr(2c0\rSrSrSrSrSrSrSrSr Sr S r g ) nvmlGpuTopologyLevel_tiJa! // e.g. Tesla K80 NVML_TOPOLOGY_INTERNAL = 0, // all devices that only need traverse a single PCIe switch NVML_TOPOLOGY_SINGLE = 10, // all devices that need not traverse a host bridge NVML_TOPOLOGY_MULTIPLE = 20, // all devices that are connected to the same host bridge NVML_TOPOLOGY_HOSTBRIDGE = 30, // all devices that are connected to the same NUMA node but possibly // multiple host bridges NVML_TOPOLOGY_NODE = 40, // all devices in the system NVML_TOPOLOGY_SYSTEM = 50, rrcrrrrr N) r r r rr(NVML_TOPOLOGY_INTERNALNVML_TOPOLOGY_SINGLENVML_TOPOLOGY_MULTIPLENVML_TOPOLOGY_HOSTBRIDGENVML_TOPOLOGY_CPUNVML_TOPOLOGY_SYSTEMrr rrrrJs-!rrPQ@c \rSrSr\"5r0\S_\S_\S_\ S_\ S_\ S_\ S_\ S _\S _\S _\S _\S _\S_\S_\S_\S_\S_\S\S\S\S\S\S0ErSrSrSr Sr!g) NVMLErrori{ UninitializedzInvalid Argumentz Not SupportedzInsufficient PermissionszAlready Initializedz Not FoundzInsufficient SizezInsufficient External PowerzDriver Not LoadedTimeoutzInterrupt Request IssuezNVML Shared Library Not FoundzFunction Not FoundzCorrupted infoROMz GPU is lostzGPU requires restartz-The operating system has blocked the request.z,RM has detected an NVML/RM version mismatch.zThe GPU is currently in usezInsufficient MemoryzNo dataz7Requested vgpu operation not available with ECC enabledz Unknown ErrorcU[:Xa[RRX5n[R U5nXlU$)zi Maps value to a proper subclass of NVMLError. See _extractNVMLErrorsAsClasses function for more details )r_valClassMappingget Exception__new__value)typrobjs rrNVMLError.__new__s< ) ,,00tzz?Z;[ ,,TZZ8// ; ; :,tzz9 9 :sA3A66BBc4URUR:H$N)r)rothers r__eq__NVMLError.__eq__szzU[[((rr N)"r r r rdictrrrrrrrrrrrrrrrrrrrrrrrrrrrr rr rrrr{sv   #(:  !  !(B  '(=     %(;  &(E  %(;     (A  %(G  &(<  %(;    "(>! " $(W# $ +,Z(E(= )+d/ 2 :)rrc [R[n[U5Vs/sHoR S5(dMUPM nnUHnS[ R "URSS5S5RSS5-n[X5nSn[U[4SU"U505n[Ul [XU5 U[RU'M gs snf)aU Generates a hierarchy of classes on top of NVMLError class. Each NVML Error gets a new NVMLError subclass. This way try,except blocks can filter appropriate exceptions more easily. NVMLError is a parent class. Each NVML_ERROR_* gets it's own subclass. e.g. NVML_ERROR_ALREADY_INITIALIZED will be turned into NVMLError_AlreadyInitialized NVML_ERROR_ NVMLError__c^U4SjnU$)Nc4>[RUT5nU$r )rr)rrvals rnew9_extractNVMLErrorsAsClasses..gen_new..news''S1 rr )rrs` rgen_new,_extractNVMLErrorsAsClasses..gen_news JrrN)sysmodulesr dir startswithstringcapwordsreplacegetattrtyperr setattrr) this_modulexnvmlErrorsNameserr_name class_nameerr_valrnew_error_classs r_extractNVMLErrorsAsClassesr-s++h'K"%k"2R"2Qll=6Qq"2OR#!FOOH4D4D]TV4WY\$]$e$efikm$nn +0  zI<)WWEU9VW%-" 9.= ""7+$Ss C C c0U[:wa [U5eU$r )rr)rets r_nvmlCheckReturnr0s |n JrcTU[;a [U$[R5 [c[ [ 5e[ [U5[U'[U[R5 $![a [ [5ef=f![R5 f=fr ) _nvmlGetFunctionPointer_cache libLoadLockacquirenvmlLibrrr#releaseAttributeErrorr)names r_nvmlGetFunctionPointerr9s ,,,T22  O45 5 ;29'42H )$ /06   ;9: : ; sBA44BBB'c \rSrSrSrSrSrg)nvmlFriendlyObjectic2UHn[XX5 M gr )r%)r dictionaryr's r__init__nvmlFriendlyObject.__init__sA DZ] +rc6URR5$r )__dict__rrs rrnvmlFriendlyObject.__str__s}}$$&&rr N)r r r rr>rrr rrr;r;s ,'rr;cn0nURHnUSn[X5nXAU'M [U5nU$Nr)_fields_r#r;)structdr'keyrrs rnvmlStructToFriendlyObjectrIs@ A __d$# Q C JrclURH#nUSnURUn[XU5 M% U$rD)rErAr%)rmodelr'rHrs rnvmlFriendlyObjectToStructrLs8 ^^d S!E" Lrc\rSrSrSrg)struct_c_nvmlUnit_ti r Nr r r rrr rrrNrN rrNcz[U5[La [US5$U$![a [U5s$f=f)Nzutf-8)r$bytesr TypeError)ss r bytes_to_strrUs@ Aw% q'? " q6M s "::c"\rSrSrSr0rSrSrg)_PrintableStructureia Abstract class that produces nicer __str__ output than ctypes.Structure. e.g. instead of: >>> print str(obj) this class will print class_name(field_name: formatted_value, field_name: formatted_value) _fmt_ dictionary of -> e.g. class that has _field_ 'hex_value', c_uint could be formatted with _fmt_ = {"hex_value" : "%08X"} to produce nicer output. Default fomratting string for all fields can be set with key "" like: _fmt_ = {"" : "%d MHz"} # e.g all values are numbers in MHz. If not set it's assumed to be just "%s" Exact format of returned str from this class is subject to change in the future. cX/nURHknUSn[X5nSnX0R;aURUnOSUR;aURSnURSU-X44-5 Mm URR S-SR U5-S-$)Nrz%s z%s: (z, ))rEr#_fmt_append __class__r join)rresultr'rHrfmts rr_PrintableStructure.__str__0sAA$CD&ECjj jjo *jj- MM6Cr8`idserialfirmwareVersionr N)r r r rc_charrErr rrrdrd>s9 " v{ 6B; FRK( Hrrdc*\rSrSrS\S-4S\4/rSrg)c_nvmlLedState_tiGcausecolorr N)r r r rri_nvmlLedColor_trErr rrrkrkGs &3, /"Hrrkc6\rSrSrS\S-4S\4S\4S\4/rSrg) c_nvmlPSUInfo_tiNstatermcurrentvoltagepowerr N)r r r rrirrErr rrrqrqNs- &3, F F & Hrrqc$\rSrSrS\4S\4/rSrg)c_nvmlUnitFanInfo_tiWspeedrrr N)r r r rr_nvmlFanState_trErr rrrwrwWs & /"Hrrwc*\rSrSrS\S-4S\4/rSrg)c_nvmlUnitFanSpeeds_ti^fanscountr N)r r r rrwrrErr rrr{r{^s $r)* &Hrr{c\rSrSrSrg)struct_c_nvmlDevice_tifr NrOr rrrrfrPrrc j\rSrSrS\S-4S\4S\4S\4S\4S\4S \4S \4S \4S \4/ rS SSSSS.rSrg) nvmlPciInfo_tikbusIdrdomainbusdevice pciDeviceIdpciSubSystemId reserved0 reserved1 reserved2 reserved3z0x%04Xz0x%02X0x%08X)rrrrrr N) r r r rrirrEr\rr rrrrksv &2+ 6  6  6" f f f f H (''''  Errc2\rSrSrS\4S\4S\4/rSS0rSrg) c_nvmlMemory_titotalfreeusedrY%d Br Nr r r r c_ulonglongrEr\rr rrrrs- +  H & !Errc2\rSrSrS\4S\4S\4/rSS0rSrg) c_nvmlBAR1Memory_ti bar1Totalbar1Freebar1UsedrYrr Nrr rrrrs- k" [! [!H & !Errc,\rSrSrS\4S\4/rSS0rSrg)c_nvmlProcessInfo_tipid usedGpuMemoryrr N) r r r rrrrEr\rr rrrrs$  +&Hf %Errc$\rSrSrS\4S\4/rSrg)c_nvmlBridgeChipInfo_tir$ fwVersionr N)r r r r_nvmlBridgeChipType_trrErr rrrrs &' fHrrc*\rSrSrS\4S\S-4/rSrg)c_nvmlBridgeChipHierarchy_ti bridgeCountbridgeChipInforr N)r r r rrrrErr rrrrs  1C78Hrrc0\rSrSrS\4S\4S\4S\4/rSrg)c_nvmlEccErrorCounts_til1Cachel2Cache deviceMemory registerFiler Nr r r rrrErr rrrrs) K K % % Hrrc,\rSrSrS\4S\4/rSS0rSrg)c_nvmlUtilization_tigpumemoryrYz%d %%r N)r r r rrrEr\rr rrrrs$  6H' "Errc*\rSrSrS\4S\S-4/rSrg)c_nvmlHwbcEntry_tihwbcIdrhrir N)r r r rrrirErr rrrrs 6 FRK(Hrrc0\rSrSrS\4S\4S\4S\4/rSr g) c_nvmlValue_tidValuiValulValullValr N) r r r rc_doublerc_ulongrrErr rrrrs)  & ' ; Hrrc$\rSrSrS\4S\4/rSrg)c_nvmlSample_ti timeStamp sampleValuer N)r r r rrrrErr rrrrs k"  &Hrrc$\rSrSrS\4S\4/rSrg)c_nvmlViolationTime_ti referenceTime violationTimer Nrr rrrrs +& +&Hrrc\rSrSrSrg)struct_c_nvmlEventSet_tir NrOr rrrrrPrrlc2\rSrSrS\4S\4S\4/rSS0rSrg)c_nvmlEventData_ti r eventType eventDatarr N) r r r rc_nvmlDevice_trrEr\rr rrrr s- >" k" k"H ( #Errc H\rSrSrS\4S\4S\4S\4S\4S\4S\S -4/rS rg ) c_nvmlAccountingStats_tigpuUtilizationmemoryUtilizationmaxMemoryUsagetime startTime isRunningreservedrr N)r r r rrrrErr rrrrsE 6" f% ;'  k" f VaZ Hrrc[5 [S5nU"5n[U5 [R 5 [ S- q[R 5 [$)a\ /** * Initialize NVML, but don't initialize any GPUs yet. * * \note nvmlInit_v3 introduces a "flags" argument, that allows passing boolean values * modifying the behaviour of nvmlInit(). * \note In NVML 5.319 new nvmlInit_v2 has replaced nvmlInit"_v1" (default in NVML 4.304 and older) that * did initialize all GPU devices in the system. * * This allows NVML to communicate with a GPU * when other GPUs in the system are unstable or in a bad state. When using this API, GPUs are * discovered and initialized in nvmlDeviceGetHandleBy* functions instead. * * \note To contrast nvmlInit_v2 with nvmlInit"_v1", NVML 4.304 nvmlInit"_v1" will fail when any detected GPU is in * a bad or unstable state. * * For all products. * * This method, should be called once before invoking any other methods in the library. * A reference count of the number of initializations is maintained. Shutdown only occurs * when the reference count reaches zero. * * @return * - \ref NVML_SUCCESS if NVML has been properly initialized * - \ref NVML_ERROR_DRIVER_NOT_LOADED if NVIDIA driver is not running * - \ref NVML_ERROR_NO_PERMISSION if NVML does not have permission to talk to the driver * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlInit nvmlInit_v2r)_LoadNvmlLibraryr9r0r3r4_nvmlLib_refcountr6r5fnr/s rnvmlInitrsO> ! /B $CS Nrc[Gc [R5 [c[RSSS:Xa[ R R[ R"SS5S5[ R R[ R"SS5S 5/n[S U5S5nUS:Xa[[5 O[U5qO [S 5q[S:Xa[[5 [R5 gg![an[[5 SnANMSnAff=f![R5 f=f) z- Load the library if it isn't loaded already Nrwin ProgramFileszC:\Program Filesz!NVIDIA Corporation\NVSMI\nvml.dllWinDirz C:\WindowszSystem32\nvml.dllc3r# UH-n[RRU5(dM)Uv M/ g7fr )ospathisfile).0r's r #_LoadNvmlLibrary..cs"(UKq277>>RSCTKs(7 7zlibnvidia-ml.so.1)r5r3r4rplatformrrr_getenvnextr0rCDLLOSErrorr6) searchPathsnvmlPathoses rrrPs  "C Ra(E1GGLL>CV)WY}~GGLL8])KMab' $((UK(UW[#\$,,-IJ'+8nG#'':";tO$%AB    !9 ,C$%ABBC    !sMD=B)DD= DD= D'D= D:!D50D=5D::D==Ec[S5nU"5n[U5 [R5 S[:a [S-q[R 5 g)a /** * Shut down NVML by releasing all GPU resources previously allocated with \ref nvmlInit(). * * For all products. * * This method should be called after NVML work is done, once for each call to \ref nvmlInit() * A reference count of the number of initializations is maintained. Shutdown only occurs * when the reference count reaches zero. For backwards compatibility, no error is reported if * nvmlShutdown() is called more times than nvmlInit(). * * @return * - \ref NVML_SUCCESS if NVML has been properly shut down * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlShutdown nvmlShutdownrrN)r9r0r3r4rr6rs rrrusN, ! 0B $CS Q rcT[S5n[UlU"U5n[U5$)Nr)r9c_char_prestyperU)r`rr/s rrrs( !2 3BBJ V*C  rc[[5n[S5nU"U[[55n[ U5 [ UR 5$)a /** * Retrieves the version of the NVML library. * * For all products. * * The version identifier is an alphanumeric string. It will not exceed 80 characters in length * (including the NULL terminator). See \ref nvmlConstants::NVML_SYSTEM_NVML_VERSION_BUFFER_SIZE. * * @param version Reference in which to return the version identifier * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_INVALID_ARGUMENT if \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small */ nvmlReturn_t DECLDIR nvmlSystemGetNVMLVersion nvmlSystemGetNVMLVersion)create_string_buffer$NVML_SYSTEM_NVML_VERSION_BUFFER_SIZEr9rr0rUr c_versionrr/s rrrsC(%%IJI !; B YEF GCS   ((rc<[S5nSn[S5nU"[U5S5nU[:waU[:wa [ U5eUR S:Xa/$[UR -nU"5nU"[U5U5n[U5 [U5$)a /** * Retrieves the IDs and firmware versions for any Host Interface Cards (HICs) in the system. * * For S-class products. * * The \a hwbcCount argument is expected to be set to the size of the input \a hwbcEntries array. * The HIC must be connected to an S-class system for it to be reported by this function. * * @param hwbcCount Size of hwbcEntries array * @param hwbcEntries Array holding information about hwbc * * @return * - \ref NVML_SUCCESS if \a hwbcCount and \a hwbcEntries have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if either \a hwbcCount or \a hwbcEntries is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a hwbcCount indicates that the \a hwbcEntries array is too small */ nvmlReturn_t DECLDIR nvmlSystemGetHicVersion rNnvmlSystemGetHicVersion) rr9byrefrrrrrr0rU)c_counthicsrr/ hic_arrays rrrs*QiG D !: ;B U7^T "C  , ,n   !GMM1I ;D U7^T "CS  rc[5n[S5nU"[U55n[U5 [ UR 5$)a* /** * Retrieves the number of units in the system. * * For S-class products. * * @param unitCount Reference in which to return the number of units * * @return * - \ref NVML_SUCCESS if \a unitCount has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unitCount is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetCount nvmlUnitGetCountrr9rr0rUrrrr/s rrr!s@"hG !3 4B U7^ CS  &&rc[U5n[5n[S5nU"U[U55n[ U5 [ U5$)a /** * Acquire the handle for a particular unit, based on its index. * * For S-class products. * * Valid indices are derived from the \a unitCount returned by \ref nvmlUnitGetCount(). * For example, if \a unitCount is 2 the valid indices are 0 and 1, corresponding to UNIT 0 and UNIT 1. * * The order in which NVML enumerates units has no guarantees of consistency between reboots. * * @param index The index of the target unit, >= 0 and < \a unitCount * @param unit Reference in which to return the unit handle * * @return * - \ref NVML_SUCCESS if \a unit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a index is invalid or \a unit is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetHandleByIndex nvmlUnitGetHandleByIndex)r c_nvmlUnit_tr9rr0rU)indexc_indexunitrr/s rr r GsG.*UmG >D !; "CS   rc~[5n[S5nU"U[U55n[U5 [ U5$)a /** * Retrieves the PSU stats for the unit. * * For S-class products. * * See \ref nvmlPSUInfo_t for details on available PSU info. * * @param unit The identifier of the target unit * @param psu Reference in which to return the PSU information * * @return * - \ref NVML_SUCCESS if \a psu has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit is invalid or \a psu is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetPsuInfo nvmlUnitGetPsuInfo)rqr9rr0rUrs rrrs?*& F !5 6B T5= !CS  rc[5n[S5nU"U[U5[U55n[U5 [ UR 5$)a /** * Retrieves the temperature readings for the unit, in degrees C. * * For S-class products. * * Depending on the product, readings may be available for intake (type=0), * exhaust (type=1) and board (type=2). * * @param unit The identifier of the target unit * @param type The type of reading to take * @param temp Reference in which to return the intake temperature * * @return * - \ref NVML_SUCCESS if \a temp has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit or \a type is invalid or \a temp is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetTemperature nvmlUnitGetTemperaturer)rr$c_temprr/s rrrsH.*XF !9 :B T6$<v /CS  %%rc~[5n[S5nU"U[U55n[U5 [ U5$)aC /** * Retrieves the fan speed readings for the unit. * * For S-class products. * * See \ref nvmlUnitFanSpeeds_t for details on available fan speed info. * * @param unit The identifier of the target unit * @param fanSpeeds Reference in which to return the fan speed information * * @return * - \ref NVML_SUCCESS if \a fanSpeeds has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit is invalid or \a fanSpeeds is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetFanSpeedInfo nvmlUnitGetFanSpeedInfo)r{r9rr0rU)rc_speedsrr/s rrr6s?*&%&H !: ;B T5? #CS  !!rc[S5n[S5nU"U[U5S5nU[:Xa[n[ U5 [ UR5$)z rnvmlUnitGetDevicesN)rr9rrrr0rUr)rrrr/s rnvmlUnitGetDeviceCountr!esOQiG !5 6B T5>4 (C ++S  &&rc[[U55n[UR-nU"5n[ S5nU"U[ U5U5n[ U5 [U5$)a /** * Retrieves the set of GPU devices that are attached to the specified unit. * * For S-class products. * * The \a deviceCount argument is expected to be set to the size of the input \a devices array. * * @param unit The identifier of the target unit * @param deviceCount Reference in which to provide the \a devices array size, and * to return the number of attached GPU devices * @param devices Reference in which to return the references to the attached GPU devices * * @return * - \ref NVML_SUCCESS if \a deviceCount and \a devices have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a deviceCount indicates that the \a devices array is too small * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit is invalid, either of \a deviceCount or \a devices is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetDevices r )rr!rrr9rr0rU)rr device_array c_devicesrr/s rr r qs^.*+D12G!GMM1LI !5 6B T5>9 -CS  ""rc[5n[S5nU"[U55n[U5 [ UR 5$)at /** * Retrieves the number of compute devices in the system. A compute device is a single GPU. * * For all products. * * Note: New nvmlDeviceGetCount_v2 (default in NVML 5.319) returns count of all devices in the system * even if nvmlDeviceGetHandleByIndex_v2 returns NVML_ERROR_NO_PERMISSION for such device. * Update your code to handle this error, or use NVML 4.304 or older nvml header file. * For backward binary compatibility reasons _v1 version of the API is still present in the shared * library. * Old _v1 version of nvmlDeviceGetCount doesn't count devices that NVML has no permission to talk to. * * @param deviceCount Reference in which to return the number of accessible devices * * @return * - \ref NVML_SUCCESS if \a deviceCount has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a deviceCount is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetCount nvmlDeviceGetCount_v2rr s rnvmlDeviceGetCountr's@0,hG !8 9B U7^ CS  &&rc[U5n[5n[S5nU"U[U55n[ U5 [ U5$)a /** * Acquire the handle for a particular device, based on its index. * * For all products. * * Valid indices are derived from the \a accessibleDevices count returned by * \ref nvmlDeviceGetCount(). For example, if \a accessibleDevices is 2 the valid indices * are 0 and 1, corresponding to GPU 0 and GPU 1. * * The order in which NVML enumerates devices has no guarantees of consistency between reboots. For that reason it * is recommended that devices be looked up by their PCI ids or UUID. See * \ref nvmlDeviceGetHandleByUUID() and \ref nvmlDeviceGetHandleByPciBusId(). * * Note: The NVML index may not correlate with other APIs, such as the CUDA device index. * * Starting from NVML 5, this API causes NVML to initialize the target GPU * NVML may initialize additional GPUs if: * - The target GPU is an SLI slave * * Note: New nvmlDeviceGetCount_v2 (default in NVML 5.319) returns count of all devices in the system * even if nvmlDeviceGetHandleByIndex_v2 returns NVML_ERROR_NO_PERMISSION for such device. * Update your code to handle this error, or use NVML 4.304 or older nvml header file. * For backward binary compatibility reasons _v1 version of the API is still present in the shared * library. * Old _v1 version of nvmlDeviceGetCount doesn't count devices that NVML has no permission to talk to. * * This means that nvmlDeviceGetHandleByIndex_v2 and _v1 can return different devices for the same index. * If you don't touch macros that map old (_v1) versions to _v2 versions at the top of the file you don't * need to worry about that. * * @param index The index of the target GPU, >= 0 and < \a accessibleDevices * @param device Reference in which to return the device handle * * @return * - \ref NVML_SUCCESS if \a device has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a index is invalid or \a device is NULL * - \ref NVML_ERROR_INSUFFICIENT_POWER if any attached devices have improperly attached external power cables * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to talk to this device * - \ref NVML_ERROR_IRQ_ISSUE if NVIDIA kernel detected an interrupt issue with the attached GPUs * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetIndex * @see nvmlDeviceGetCount */ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByIndex nvmlDeviceGetHandleByIndex_v2)rrr9rr0rU)r rrrr/s rnvmlDeviceGetHandleByIndexr*sJd/`UmG  F !@ AB WeFm $CS  rc[U5n[5n[S5nU"U[U55n[ U5 [ U5$)ad /** * Acquire the handle for a particular device, based on its board serial number. * * For Fermi &tm; or newer fully supported devices. * * This number corresponds to the value printed directly on the board, and to the value returned by * \ref nvmlDeviceGetSerial(). * * @deprecated Since more than one GPU can exist on a single board this function is deprecated in favor * of \ref nvmlDeviceGetHandleByUUID. * For dual GPU boards this function will return NVML_ERROR_INVALID_ARGUMENT. * * Starting from NVML 5, this API causes NVML to initialize the target GPU * NVML may initialize additional GPUs as it searches for the target GPU * * @param serial The board serial number of the target GPU * @param device Reference in which to return the device handle * * @return * - \ref NVML_SUCCESS if \a device has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a serial is invalid, \a device is NULL or more than one * device has the same serial (dual GPU boards) * - \ref NVML_ERROR_NOT_FOUND if \a serial does not match a valid device on the system * - \ref NVML_ERROR_INSUFFICIENT_POWER if any attached devices have improperly attached external power cables * - \ref NVML_ERROR_IRQ_ISSUE if NVIDIA kernel detected an interrupt issue with the attached GPUs * - \ref NVML_ERROR_GPU_IS_LOST if any GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetSerial * @see nvmlDeviceGetHandleByUUID */ nvmlReturn_t DECLDIR nvmlDeviceGetHandleBySerial nvmlDeviceGetHandleBySerialrrr9rr0rU)rgc_serialrrr/s rr,r,CsKH!DH  F !> ?B XuV} %CS  rc[U5n[5n[S5nU"U[U55n[ U5 [ U5$)aH /** * Acquire the handle for a particular device, based on its globally unique immutable UUID associated with each device. * * For all products. * * @param uuid The UUID of the target GPU * @param device Reference in which to return the device handle * * Starting from NVML 5, this API causes NVML to initialize the target GPU * NVML may initialize additional GPUs as it searches for the target GPU * * @return * - \ref NVML_SUCCESS if \a device has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a uuid is invalid or \a device is null * - \ref NVML_ERROR_NOT_FOUND if \a uuid does not match a valid device on the system * - \ref NVML_ERROR_INSUFFICIENT_POWER if any attached devices have improperly attached external power cables * - \ref NVML_ERROR_IRQ_ISSUE if NVIDIA kernel detected an interrupt issue with the attached GPUs * - \ref NVML_ERROR_GPU_IS_LOST if any GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetUUID */ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByUUID nvmlDeviceGetHandleByUUIDr-)uuidc_uuidrrr/s rr0r0sH62d^F  F !< =B VU6] #CS  rc[U5n[5n[S5nU"U[U55n[ U5 [ U5$)a /** * Acquire the handle for a particular device, based on its PCI bus id. * * For all products. * * This value corresponds to the nvmlPciInfo_t::busId returned by \ref nvmlDeviceGetPciInfo(). * * Starting from NVML 5, this API causes NVML to initialize the target GPU * NVML may initialize additional GPUs if: * - The target GPU is an SLI slave * * \note NVML 4.304 and older version of nvmlDeviceGetHandleByPciBusId"_v1" returns NVML_ERROR_NOT_FOUND * instead of NVML_ERROR_NO_PERMISSION. * * @param pciBusId The PCI bus id of the target GPU * @param device Reference in which to return the device handle * * @return * - \ref NVML_SUCCESS if \a device has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a pciBusId is invalid or \a device is NULL * - \ref NVML_ERROR_NOT_FOUND if \a pciBusId does not match a valid device on the system * - \ref NVML_ERROR_INSUFFICIENT_POWER if the attached device has improperly attached external power cables * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to talk to this device * - \ref NVML_ERROR_IRQ_ISSUE if NVIDIA kernel detected an interrupt issue with the attached GPUs * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByPciBusId nvmlDeviceGetHandleByPciBusId_v2r-)pciBusIdc_busIdrrr/s rnvmlDeviceGetHandleByPciBusIdr7sJ@<x G  F !C DB WeFm $CS  rc[[5n[S5nU"X[[55n[ U5 [ UR 5$)a /** * Retrieves the name of this device. * * For all products. * * The name is an alphanumeric string that denotes a particular product, e.g. Tesla &tm; C2070. It will not * exceed 64 characters in length (including the NULL terminator). See \ref * nvmlConstants::NVML_DEVICE_NAME_BUFFER_SIZE. * * @param device The identifier of the target device * @param name Reference in which to return the product name * @param length The maximum allowed length of the string returned in \a name * * @return * - \ref NVML_SUCCESS if \a name has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a name is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetName nvmlDeviceGetName)rNVML_DEVICE_NAME_BUFFER_SIZEr9rr0rUr)handlerrr/s rr9r9sC2""> ?F !4 5B VV$@A BCS  %%rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves the device boardId from 0-N. * Devices with the same boardId indicate GPUs connected to the same PLX. Use in conjunction with * \ref nvmlDeviceGetMultiGpuBoard() to decide if they are on the same board as well. * The boardId returned is a unique ID for the current configuration. Uniqueness and ordering across * reboots and system configurations is not guaranteed (i.e. if a Tesla K40c returns 0x100 and * the two GPUs on a Tesla K10 in the same system returns 0x200 it is not guaranteed they will * always return those values but they will always be different from each other). * * * For Fermi &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param boardId Reference in which to return the device's board ID * * @return * - \ref NVML_SUCCESS if \a boardId has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a boardId is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetBoardId nvmlDeviceGetBoardIdr)r;c_idrr/s rr=r=/s=6 8D !7 8B VU4[ !CS  ##rc[5n[S5nU"U[U55n[U5 [ UR 5$)a] /** * Retrieves whether the device is on a Multi-GPU Board * Devices that are on multi-GPU boards will set \a multiGpuBool to a non-zero value. * * For Fermi &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param multiGpuBool Reference in which to return a zero or non-zero value * to indicate whether the device is on a multi GPU board * * @return * - \ref NVML_SUCCESS if \a multiGpuBool has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a multiGpuBool is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMultiGpuBoard nvmlDeviceGetMultiGpuBoardr)r; c_multiGpurr/s rr@r@Ps@,J != >B VU:& 'CS  (( ))rc[5n[S5nU"U[U55n[U5 [ UR 5$)a; /** * Retrieves the brand of this device. * * For all products. * * The type is a member of \ref nvmlBrandType_t defined above. * * @param device The identifier of the target device * @param type Reference in which to return the product brand type * * @return * - \ref NVML_SUCCESS if \a name has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a type is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetBrand nvmlDeviceGetBrand)_nvmlBrandType_tr9rr0rUr)r;c_typerr/s rrCrCls>* F !5 6B VU6] #CS  %%rc[[5n[S5nU"X[[55n[ U5 [ UR 5$)ad /** * Retrieves the globally unique board serial number associated with this device's board. * * For all products with an inforom. * * The serial number is an alphanumeric string that will not exceed 30 characters (including the NULL terminator). * This number matches the serial number tag that is physically attached to the board. See \ref * nvmlConstants::NVML_DEVICE_SERIAL_BUFFER_SIZE. * * @param device The identifier of the target device * @param serial Reference in which to return the board/module serial number * @param length The maximum allowed length of the string returned in \a serial * * @return * - \ref NVML_SUCCESS if \a serial has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a serial is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetSerial nvmlDeviceGetSerial)rNVML_DEVICE_SERIAL_BUFFER_SIZEr9rr0rUr)r;r.rr/s rrGrGsC4$$BCH !6 7B Vv&DE FCS  ''rc[U-nU"5n[S5nU"X[U55n[U5 [ U5$)a^ /** * Retrieves an array of unsigned ints (sized to cpuSetSize) of bitmasks with the ideal CPU affinity for the device * For example, if processors 0, 1, 32, and 33 are ideal for the device and cpuSetSize == 2, * result[0] = 0x3, result[1] = 0x3 * * For Kepler &tm; or newer fully supported devices. * Supported on Linux only. * * @param device The identifier of the target device * @param cpuSetSize The size of the cpuSet array that is safe to access * @param cpuSet Array reference in which to return a bitmask of CPUs, 64 CPUs per * unsigned long on 64-bit machines, 32 on 32-bit machines * * @return * - \ref NVML_SUCCESS if \a cpuAffinity has been filled * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, cpuSetSize == 0, or cpuSet is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetCpuAffinity nvmlDeviceGetCpuAffinity)rr9rr0rU)r; cpuSetSizeaffinity_array c_affinityrr/s rrJrJsE2!:-N!J !; B V*CS rc[5n[S5nU"U[U55n[U5 [ UR 5$)a% /** * Retrieves minor number for the device. The minor number for the device is such that the Nvidia device node file for * each GPU will have the form /dev/nvidia[minor number]. * * For all products. * Supported only for Linux * * @param device The identifier of the target device * @param minorNumber Reference in which to return the minor number for the device * @return * - \ref NVML_SUCCESS if the minor number is successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a minorNumber is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMinorNumber nvmlDeviceGetMinorNumberr)r;c_minor_numberrr/s rrZrZ s@*XN !; * +CS ,, --rc[[5n[S5nU"X[[55n[ U5 [ UR 5$)a /** * Retrieves the globally unique immutable UUID associated with this device, as a 5 part hexadecimal string, * that augments the immutable, board serial identifier. * * For all products. * * The UUID is a globally unique identifier. It is the only available identifier for pre-Fermi-architecture products. * It does NOT correspond to any identifier printed on the board. It will not exceed 80 characters in length * (including the NULL terminator). See \ref nvmlConstants::NVML_DEVICE_UUID_BUFFER_SIZE. * * @param device The identifier of the target device * @param uuid Reference in which to return the GPU UUID * @param length The maximum allowed length of the string returned in \a uuid * * @return * - \ref NVML_SUCCESS if \a uuid has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a uuid is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetUUID nvmlDeviceGetUUID)rNVML_DEVICE_UUID_BUFFER_SIZEr9rr0rUr)r;r2rr/s rr]r]5 sC6""> ?F !4 5B VV$@A BCS  %%rc[[5n[S5nU"U[U5U[ [55n[ U5 [ UR5$)aN /** * Retrieves the version information for the device's infoROM object. * * For all products with an inforom. * * Fermi and higher parts have non-volatile on-board memory for persisting device info, such as aggregate * ECC counts. The version of the data structures in this memory may change from time to time. It will not * exceed 16 characters in length (including the NULL terminator). * See \ref nvmlConstants::NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE. * * See \ref nvmlInforomObject_t for details on the available infoROM objects. * * @param device The identifier of the target device * @param object The target infoROM object * @param version Reference in which to return the infoROM version * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have an infoROM * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetInforomImageVersion */ nvmlReturn_t DECLDIR nvmlDeviceGetInforomVersion nvmlDeviceGetInforomVersion)r'NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZEr9_nvmlInforomObject_trr0rUr)r; infoRomObjectrrr/s rr`r`V sR@%%LMI !> ?B V)-8 VCD FCS   ((rc[[5n[S5nU"X[[55n[ U5 [ UR 5$)a /** * Retrieves the global infoROM image version * * For all products with an inforom. * * Image version just like VBIOS version uniquely describes the exact version of the infoROM flashed on the board * in contrast to infoROM object version which is only an indicator of supported features. * Version string will not exceed 16 characters in length (including the NULL terminator). * See \ref nvmlConstants::NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE. * * @param device The identifier of the target device * @param version Reference in which to return the infoROM image version * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have an infoROM * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetInforomVersion */ nvmlReturn_t DECLDIR nvmlDeviceGetInforomImageVersion nvmlDeviceGetInforomImageVersion)rrar9rr0rUrr;rrr/s rrere~ sC:%%LMI !C DB V'N O PCS   ((rc[5n[S5nU"U[U55n[U5 [ UR 5$)a. /** * Retrieves the checksum of the configuration stored in the device's infoROM. * * For all products with an inforom. * * Can be used to make sure that two GPUs have the exact same configuration. * Current checksum takes into account configuration stored in PWR and ECC infoROM objects. * Checksum can change between driver releases or when user changes configuration (e.g. disable/enable ECC) * * @param device The identifier of the target device * @param checksum Reference in which to return the infoROM configuration checksum * * @return * - \ref NVML_SUCCESS if \a checksum has been set * - \ref NVML_ERROR_CORRUPTED_INFOROM if the device's checksum couldn't be retrieved due to infoROM corruption * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a checksum is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetInforomConfigurationChecksum )nvmlDeviceGetInforomConfigurationChecksumr)r; c_checksumrr/s rrhrh s@2J !L MB VU:& 'CS  (( ))rc@[S5nU"U5n[U5 g)a /** * Reads the infoROM from the flash and verifies the checksums. * * For all products with an inforom. * * @param device The identifier of the target device * * @return * - \ref NVML_SUCCESS if infoROM is not corrupted * - \ref NVML_ERROR_CORRUPTED_INFOROM if the device's infoROM is corrupted * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceValidateInforom nvmlDeviceValidateInforomNrUrVs rrkrk s#& !!< =B V*CS rc[5n[S5nU"U[U55n[U5 [ UR 5$)a" /** * Retrieves the display mode for the device. * * For all products. * * This method indicates whether a physical display (e.g. monitor) is currently connected to * any of the device's connectors. * * See \ref nvmlEnableState_t for details on allowed modes. * * @param device The identifier of the target device * @param display Reference in which to return the display mode * * @return * - \ref NVML_SUCCESS if \a display has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a display is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetDisplayMode nvmlDeviceGetDisplayMode_nvmlEnableState_tr9rr0rUrr;c_moderr/s rrmrm s>2 !F !; 6 !F != >B VU6] #CS  %%rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves the persistence mode associated with this device. * * For all products. * For Linux only. * * When driver persistence mode is enabled the driver software state is not torn down when the last * client disconnects. By default this feature is disabled. * * See \ref nvmlEnableState_t for details on allowed modes. * * @param device The identifier of the target device * @param mode Reference in which to return the current driver persistence mode * * @return * - \ref NVML_SUCCESS if \a mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetPersistenceMode() */ nvmlReturn_t DECLDIR nvmlDeviceGetPersistenceMode nvmlDeviceGetPersistenceModern)r;rrr/s rruru s>8!"G !? @B VU7^ $CS  &&rc|[5n[S5nU"U[U55n[U5 [ U5$)aA /** * Retrieves the PCI attributes of this device. * * For all products. * * See \ref nvmlPciInfo_t for details on the available PCI info. * * @param device The identifier of the target device * @param pci Reference in which to return the PCI info * * @return * - \ref NVML_SUCCESS if \a pci has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a pci is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPciInfo nvmlDeviceGetPciInfo_v2)rr9rr0rU)r;rrr/s rnvmlDeviceGetPciInforx= s9*_F !: ;B VU6] #CS  rc[5n[S5nU"U[U5[U55n[ U5 [ UR 5$)a* /** * Retrieves the current clock speeds for the device. * * For Fermi &tm; or newer fully supported devices. * * See \ref nvmlClockType_t for details on available clock information. * * @param device The identifier of the target device * @param type Identify which clock domain to query * @param clock Reference in which to return the clock speed in MHz * * @return * - \ref NVML_SUCCESS if \a clock has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clock is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device cannot report the specified clock * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetClockInfo nvmlDeviceGetClockInforr9_nvmlClockType_trr0rUrr;r$c_clockrr/s rrzrzX sE.hG !9 :B V%d+U7^ w2w}}%A LL %& nrc[S5n[S5nU"U[U5[U5S5nU[:Xa/$U[:Xau[UR -nU"5nU"U[U5[U5U5n[ U5 /n[UR 5HnURXh5 M U$[U5e)a# /** * Retrieves the list of possible graphics clocks that can be used as an argument for \ref nvmlDeviceSetApplicationsClocks. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param memoryClockMHz Memory clock for which to return possible graphics clocks * @param count Reference in which to provide the \a clocksMHz array size, and * to return the number of elements * @param clocksMHz Reference in which to return the clocks in MHz * * @return * - \ref NVML_SUCCESS if \a count and \a clocksMHz have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_NOT_FOUND if the specified \a memoryClockMHz is not a supported frequency * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clock is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a count is too small * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetApplicationsClocks * @see nvmlDeviceGetSupportedMemoryClocks */ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedGraphicsClocks r$nvmlDeviceGetSupportedGraphicsClocksNr) r;memoryClockMHzrrr/rrrrs rrr s:QiG !G HB VVN+U7^T BC | - - - >/wJw}}%A LL %& nrc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves the intended operating speed of the device's fan. * * Note: The reported speed is the intended fan speed. If the fan is physically blocked and unable to spin, the * output will not match the actual fan speed. * * For all discrete products with dedicated fans. * * The fan speed is expressed as a percent of the maximum, i.e. full speed is 100%. * * @param device The identifier of the target device * @param speed Reference in which to return the fan speed percentage * * @return * - \ref NVML_SUCCESS if \a speed has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a speed is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have a fan * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetFanSpeed nvmlDeviceGetFanSpeedr)r;c_speedrr/s rrr? s=2hG !8 9B VU7^ $CS  &&rc[5n[S5nU"U[U5[U55n[ U5 [ UR 5$)aX /** * Retrieves the current temperature readings for the device, in degrees C. * * For all products. * * See \ref nvmlTemperatureSensors_t for details on available temperature sensors. * * @param device The identifier of the target device * @param sensorType Flag that indicates which sensor reading to retrieve * @param temp Reference in which to return the temperature reading * * @return * - \ref NVML_SUCCESS if \a temp has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a sensorType is invalid or \a temp is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have the specified sensor * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetTemperature nvmlDeviceGetTemperature)rr9_nvmlTemperatureSensors_trr0rUr)r;sensorrrr/s rrr^ sE.XF !; 0H !: ;B VU8_ %CS  ''rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves the current performance state for the device. * * For Fermi &tm; or newer fully supported devices. * * See \ref nvmlPstates_t for details on allowed performance states. * * @param device The identifier of the target device * @param pState Reference in which to return the performance state reading * * @return * - \ref NVML_SUCCESS if \a pState has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a pState is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPerformanceState nvmlDeviceGetPerformanceStaterrs rrr s>,H !@ AB VU8_ %CS  ''rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * This API has been deprecated. * * Retrieves the power management mode associated with this device. * * For products from the Fermi family. * - Requires \a NVML_INFOROM_POWER version 3.0 or higher. * * For from the Kepler or newer families. * - Does not require \a NVML_INFOROM_POWER object. * * This flag indicates whether any power management algorithm is currently active on the device. An * enabled state does not necessarily mean the device is being actively throttled -- only that * that the driver will do so if the appropriate conditions are met. * * See \ref nvmlEnableState_t for details on allowed modes. * * @param device The identifier of the target device * @param mode Reference in which to return the current power management mode * * @return * - \ref NVML_SUCCESS if \a mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementMode nvmlDeviceGetPowerManagementModern)r; c_pcapModerr/s rrr sB@$%J !C DB VU:& 'CS  (( ))rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves the power management limit associated with this device. * * For Fermi &tm; or newer fully supported devices. * * The power limit defines the upper boundary for the card's power draw. If * the card's total power draw reaches this limit the power management algorithm kicks in. * * This reading is only available if power management mode is supported. * See \ref nvmlDeviceGetPowerManagementMode. * * @param device The identifier of the target device * @param limit Reference in which to return the power management limit in milliwatts * * @return * - \ref NVML_SUCCESS if \a limit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a limit is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementLimit !nvmlDeviceGetPowerManagementLimitrr;c_limitrr/s rrr s=4hG !D EB VU7^ $CS  &&rc[5n[5n[S5nU"U[U5[U55n[U5 URUR/$)a /** * Retrieves information about possible values of power management limits on this device. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param minLimit Reference in which to return the minimum power management limit in milliwatts * @param maxLimit Reference in which to return the maximum power management limit in milliwatts * * @return * - \ref NVML_SUCCESS if \a minLimit and \a maxLimit have been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a minLimit or \a maxLimit is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetPowerManagementLimit */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementLimitConstraints ,nvmlDeviceGetPowerManagementLimitConstraintsrP)r; c_minLimit c_maxLimitrr/s rrr sT.JJ !O PB VU:&j(9 :CS   j.. //rc[5n[S5nU"U[U55n[U5 [ UR 5$)a1 /** * Retrieves default power management limit on this device, in milliwatts. * Default power management limit is a power management limit that the device boots with. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param defaultLimit Reference in which to return the default power management limit in milliwatts * * @return * - \ref NVML_SUCCESS if \a defaultLimit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a defaultLimit is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementDefaultLimit (nvmlDeviceGetPowerManagementDefaultLimitrrs rrr8 s=*hG !K LB VU7^ $CS  &&rc[5n[S5nU"U[U55n[U5 [ UR 5$)al /** * Get the effective power limit that the driver enforces after taking into account all limiters * * Note: This can be different from the \ref nvmlDeviceGetPowerManagementLimit if other limits are set elsewhere * This includes the out of band power limit interface * * For Kepler &tm; or newer fully supported devices. * * @param device The device to communicate with * @param limit Reference in which to return the power management limit in milliwatts * * @return * - \ref NVML_SUCCESS if \a limit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a limit is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetEnforcedPowerLimit nvmlDeviceGetEnforcedPowerLimitrrs rrrU s=.hG !B CB VU7^ $CS  &&rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves power usage for this GPU in milliwatts and its associated circuitry (e.g. memory) * * For Fermi &tm; or newer fully supported devices. * * On Fermi and Kepler GPUs the reading is accurate to within +/- 5% of current power draw. * * It is only available if power management mode is supported. See \ref nvmlDeviceGetPowerManagementMode. * * @param device The identifier of the target device * @param power Reference in which to return the power usage information * * @return * - \ref NVML_SUCCESS if \a power has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a power is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support power readings * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerUsage nvmlDeviceGetPowerUsager)r;c_wattsrr/s rrrr s=0hG !: ;B VU7^ $CS  &&rc[5n[5n[S5nU"U[U5[U55n[U5 URUR/$)a, /** * Retrieves the current GOM and pending GOM (the one that GPU will switch to after reboot). * * For GK110 M-class and X-class Tesla &tm; products from the Kepler family. * Modes \ref NVML_GOM_LOW_DP and \ref NVML_GOM_ALL_ON are supported on fully supported GeForce products. * Not supported on Quadro ® and Tesla &tm; C-class products. * * @param device The identifier of the target device * @param current Reference in which to return the current GOM * @param pending Reference in which to return the pending GOM * * @return * - \ref NVML_SUCCESS if \a mode has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a current or \a pending is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlGpuOperationMode_t * @see nvmlDeviceSetGpuOperationMode */ nvmlReturn_t DECLDIR nvmlDeviceGetGpuOperationMode nvmlDeviceGetGpuOperationMode)_nvmlGpuOperationMode_tr9rr0rr; c_currStatec_pendingStaterr/s rrr sV4*+K,.N !@ AB VU;'~)> ?CS   ~33 44rc[U5S$rDrr;s r$nvmlDeviceGetCurrentGpuOperationModer  ( 0 33rc[U5S$Nrrrs r$nvmlDeviceGetPendingGpuOperationModer rrc|[5n[S5nU"U[U55n[U5 [ U5$)a /** * Retrieves the amount of used, free and total memory available on the device, in bytes. * * For all products. * * Enabling ECC reduces the amount of total available memory, due to the extra required parity bits. * Under WDDM most device memory is allocated and managed on startup by Windows. * * Under Linux and Windows TCC, the reported amount of used memory is equal to the sum of memory allocated * by all active channels on the device. * * See \ref nvmlMemory_t for details on available memory info. * * @param device The identifier of the target device * @param memory Reference in which to return the memory information * * @return * - \ref NVML_SUCCESS if \a memory has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a memory is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMemoryInfo nvmlDeviceGetMemoryInfo)rr9rr0rU)r;c_memoryrr/s rrr s:6H !: ;B VU8_ %CS  !!rc|[5n[S5nU"U[U55n[U5 [ U5$)as /** * Gets Total, Available and Used size of BAR1 memory. * * BAR1 is used to map the FB (device memory) so that it can be directly accessed by the CPU or by 3rd party * devices (peer-to-peer on the PCIE bus). * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param bar1Memory Reference in which BAR1 memory * information is returned. * * @return * - \ref NVML_SUCCESS if BAR1 memory is successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a bar1Memory is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * */ nvmlReturn_t DECLDIR nvmlDeviceGetBAR1MemoryInfo nvmlDeviceGetBAR1MemoryInfo)rr9rr0rU)r; c_bar1_memoryrr/s rrr s;2'(M !> ?B VU=) *CS  &&rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves the current compute mode for the device. * * For all products. * * See \ref nvmlComputeMode_t for details on allowed compute modes. * * @param device The identifier of the target device * @param mode Reference in which to return the current compute mode * * @return * - \ref NVML_SUCCESS if \a mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetComputeMode() */ nvmlReturn_t DECLDIR nvmlDeviceGetComputeMode nvmlDeviceGetComputeMode)_nvmlComputeMode_tr9rr0rUrrps rrr s>0 !F !; ?CS   ~33 44rc[U5S$rDrrs rnvmlDeviceGetCurrentEccModer>   ' **rc[U5S$rrrs rnvmlDeviceGetPendingEccModerB rrc[5n[S5nU"U[U5[U5[ U55n[ U5 [ UR5$)a^ /** * Retrieves the total ECC error counts for the device. * * For Fermi &tm; or newer fully supported devices. * Only applicable to devices with ECC. * Requires \a NVML_INFOROM_ECC version 1.0 or higher. * Requires ECC Mode to be enabled. * * The total error count is the sum of errors across each of the separate memory systems, i.e. the total set of * errors across the entire device. * * See \ref nvmlMemoryErrorType_t for a description of available error types.\n * See \ref nvmlEccCounterType_t for a description of available counter types. * * @param device The identifier of the target device * @param errorType Flag that specifies the type of the errors. * @param counterType Flag that specifies the counter-type of the errors. * @param eccCounts Reference in which to return the specified ECC errors * * @return * - \ref NVML_SUCCESS if \a eccCounts has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device, \a errorType or \a counterType is invalid, or \a eccCounts is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceClearEccErrorCounts() */ nvmlReturn_t DECLDIR nvmlDeviceGetTotalEccErrors nvmlDeviceGetTotalEccErrors)rr9_nvmlMemoryErrorType_t_nvmlEccCounterType_trr0rUr)r; errorType counterTyperrr/s rrrE sPBmG !> ?B V+I6  ,eGn >CS  &&rc[5n[S5nU"U[U5[U5[ U55n[ U5 [ U5$)aI /** * Retrieves the detailed ECC error counts for the device. * * @deprecated This API supports only a fixed set of ECC error locations * On different GPU architectures different locations are supported * See \ref nvmlDeviceGetMemoryErrorCounter * * For Fermi &tm; or newer fully supported devices. * Only applicable to devices with ECC. * Requires \a NVML_INFOROM_ECC version 2.0 or higher to report aggregate location-based ECC counts. * Requires \a NVML_INFOROM_ECC version 1.0 or higher to report all other ECC counts. * Requires ECC Mode to be enabled. * * Detailed errors provide separate ECC counts for specific parts of the memory system. * * Reports zero for unsupported ECC error counters when a subset of ECC error counters are supported. * * See \ref nvmlMemoryErrorType_t for a description of available bit types.\n * See \ref nvmlEccCounterType_t for a description of available counter types.\n * See \ref nvmlEccErrorCounts_t for a description of provided detailed ECC counts. * * @param device The identifier of the target device * @param errorType Flag that specifies the type of the errors. * @param counterType Flag that specifies the counter-type of the errors. * @param eccCounts Reference in which to return the specified ECC errors * * @return * - \ref NVML_SUCCESS if \a eccCounts has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device, \a errorType or \a counterType is invalid, or \a eccCounts is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceClearEccErrorCounts() */ nvmlReturn_t DECLDIR nvmlDeviceGetDetailedEccErrors nvmlDeviceGetDetailedEccErrors)rr9rrrr0rU)r;rrc_countsrr/s rrrn sMP&'H !A BB V+I6  ,eHo ?CS  !!rc [5n[S5nU"U[U5[U5[ U5[ U55n[ U5 [UR5$)aE /** * Retrieves the requested memory error counter for the device. * * For Fermi &tm; or newer fully supported devices. * Requires \a NVML_INFOROM_ECC version 2.0 or higher to report aggregate location-based memory error counts. * Requires \a NVML_INFOROM_ECC version 1.0 or higher to report all other memory error counts. * * Only applicable to devices with ECC. * * Requires ECC Mode to be enabled. * * See \ref nvmlMemoryErrorType_t for a description of available memory error types.\n * See \ref nvmlEccCounterType_t for a description of available counter types.\n * See \ref nvmlMemoryLocation_t for a description of available counter locations.\n * * @param device The identifier of the target device * @param errorType Flag that specifies the type of error. * @param counterType Flag that specifies the counter-type of the errors. * @param locationType Specifies the location of the counter. * @param count Reference in which to return the ECC counter * * @return * - \ref NVML_SUCCESS if \a count has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device, \a bitTyp,e \a counterType or \a locationType is * invalid, or \a count is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support ECC error reporting in the specified memory * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMemoryErrorCounter nvmlDeviceGetMemoryErrorCounter) rr9rr_nvmlMemoryLocation_trr0rUr)r;rr locationTyperrr/s rrr s[DmG !B CB V #I . "; / "< 0 7^  C S  &&rc|[5n[S5nU"U[U55n[U5 [ U5$)a /** * Retrieves the current utilization rates for the device's major subsystems. * * For Fermi &tm; or newer fully supported devices. * * See \ref nvmlUtilization_t for details on available utilization rates. * * \note During driver initialization when ECC is enabled one can see high GPU and Memory Utilization readings. * This is caused by ECC Memory Scrubbing mechanism that is performed during driver initialization. * * @param device The identifier of the target device * @param utilization Reference in which to return the utilization information * * @return * - \ref NVML_SUCCESS if \a utilization has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a utilization is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetUtilizationRates nvmlDeviceGetUtilizationRates)rr9rr0rU)r;c_utilrr/s rrr s:2! "F !@ AB VU6] #CS  rc[5n[5n[S5nU"U[U5[U55n[U5 URUR/$)aR /** * Retrieves the current utilization and sampling size in microseconds for the Encoder * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param utilization Reference to an unsigned int for encoder utilization info * @param samplingPeriodUs Reference to an unsigned int for the sampling period in US * * @return * - \ref NVML_SUCCESS if \a utilization has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a utilization is NULL, or \a samplingPeriodUs is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetEncoderUtilization nvmlDeviceGetEncoderUtilizationrPr;rc_samplingPeriodrr/s rrr T*XFx !B CB VU6]E*:$; ?CS   ~33 44rc[U5S$rDrrs rnvmlDeviceGetCurrentDriverModelr` #F +A ..rc[U5S$rrrs rnvmlDeviceGetPendingDriverModelrdrrc[[5n[S5nU"X[[55n[ U5 [ UR 5$)a{ /** * Get VBIOS version of the device. * * For all products. * * The VBIOS version may change from time to time. It will not exceed 32 characters in length * (including the NULL terminator). See \ref nvmlConstants::NVML_DEVICE_VBIOS_VERSION_BUFFER_SIZE. * * @param device The identifier of the target device * @param version Reference to which to return the VBIOS version * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetVbiosVersion nvmlDeviceGetVbiosVersion)r%NVML_DEVICE_VBIOS_VERSION_BUFFER_SIZEr9rr0rUrrfs rrrhsC0%%JKI !< =B V'L M NCS   ((rc[S5n[S5nU"U[U5S5nU[:Xa/$U[:XaUR S-S-Ul[ UR -nU"5nU"U[U5U5n[U5 /n[UR 5HFn[XW5nUR[R :XaSUl URU5 MH U$[U5e)a{ /** * Get information about processes with a compute context on a device * * For Fermi &tm; or newer fully supported devices. * * This function returns information only about compute running processes (e.g. CUDA application which have * active context). Any graphics applications (e.g. using OpenGL, DirectX) won't be listed by this function. * * To query the current number of running compute processes, call this function with *infoCount = 0. The * return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if none are running. For this call * \a infos is allowed to be NULL. * * The usedGpuMemory field returned is all of the memory used by the application. * * Keep in mind that information returned by this call is dynamic and the number of elements might change in * time. Allocate more space for \a infos table in case new compute processes are spawned. * * @param device The identifier of the target device * @param infoCount Reference in which to provide the \a infos array size, and * to return the number of returned elements * @param infos Reference in which to return the process information * * @return * - \ref NVML_SUCCESS if \a infoCount and \a infos have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a infoCount indicates that the \a infos array is too small * \a infoCount will contain minimal amount of space necessary for * the call to complete * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, either of \a infoCount or \a infos is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see \ref nvmlSystemGetProcessName */ nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses r$nvmlDeviceGetComputeRunningProcessesNrrrr9rrrrrr0rrIr"NVML_VALUE_NOT_AVAILABLE_ulonglongr]r r;rrr/ proc_arrayc_procsrrrs rrrsNQiG !G HB VU7^T *C | - - )A- (7==8 ,w1w}}%A,WZ8C!!%G%M%MM$(! LL  & nrc[S5n[S5nU"U[U5S5nU[:Xa/$U[:XaUR S-S-Ul[ UR -nU"5nU"U[U5U5n[U5 /n[UR 5HFn[XW5nUR[R :XaSUl URU5 MH U$[U5e)a /** * Get information about processes with a graphics context on a device * * For Kepler &tm; or newer fully supported devices. * * This function returns information only about graphics based processes * (eg. applications using OpenGL, DirectX) * * To query the current number of running graphics processes, call this function with *infoCount = 0. The * return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if none are running. For this call * \a infos is allowed to be NULL. * * The usedGpuMemory field returned is all of the memory used by the application. * * Keep in mind that information returned by this call is dynamic and the number of elements might change in * time. Allocate more space for \a infos table in case new graphics processes are spawned. * * @param device The identifier of the target device * @param infoCount Reference in which to provide the \a infos array size, and * to return the number of returned elements * @param infos Reference in which to return the process information * * @return * - \ref NVML_SUCCESS if \a infoCount and \a infos have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a infoCount indicates that the \a infos array is too small * \a infoCount will contain minimal amount of space necessary for * the call to complete * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, either of \a infoCount or \a infos is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see \ref nvmlSystemGetProcessName */ nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses r%nvmlDeviceGetGraphicsRunningProcessesNrrrrs rrrsNQiG !H IB VU7^T *C | - - )A- (7==8 ,w1w}}%A,WZ8C!!%G%M%MM$(! LL  & nrc[5n[5n[S5nU"U[U5[U55n[U5 URUR/$)a /** * Retrieve the current state of Auto Boosted clocks on a device and store it in \a isEnabled * * For Kepler &tm; or newer fully supported devices. * * Auto Boosted clocks are enabled by default on some hardware, allowing the GPU to run at higher clock rates * to maximize performance as thermal limits allow. * * On Pascal and newer hardware, Auto Aoosted clocks are controlled through application clocks. * Use \ref nvmlDeviceSetApplicationsClocks and \ref nvmlDeviceResetApplicationsClocks to control Auto Boost * behavior. * * @param device The identifier of the target device * @param isEnabled Where to store the current state of Auto Boosted clocks of the target device * @param defaultIsEnabled Where to store the default Auto Boosted clocks behavior of the target device that the device will * revert to when no applications are using the GPU * * @return * - \ref NVML_SUCCESS If \a isEnabled has been been set with the Auto Boosted clocks state of \a device * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a isEnabled is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support Auto Boosted clocks * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * */ nvmlReturn_t DECLDIR nvmlDeviceGetAutoBoostedClocksEnabled %nvmlDeviceGetAutoBoostedClocksEnabledr)r; c_isEnabledc_defaultIsEnabledrr/s rrrsY<%&K+- !H IB VU;'/A)B CCS   177 88rcT[S5nU"U[U55n[U5 g)a /** * Set the LED state for the unit. The LED can be either green (0) or amber (1). * * For S-class products. * Requires root/admin permissions. * * This operation takes effect immediately. * * * Current S-Class products don't provide unique LEDs for each unit. As such, both front * and back LEDs will be toggled in unison regardless of which unit is specified with this command. * * See \ref nvmlLedColor_t for available colors. * * @param unit The identifier of the target unit * @param color The target LED color * * @return * - \ref NVML_SUCCESS if the LED color has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit or \a color is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlUnitGetLedState() */ nvmlReturn_t DECLDIR nvmlUnitSetLedState nvmlUnitSetLedStateN)r9ror0)rrnrr/s rr r <s+> !!6 7B T?5) *CS rcT[S5nU"U[U55n[U5 g)ab /** * Set the persistence mode for the device. * * For all products. * For Linux only. * Requires root/admin permissions. * * The persistence mode determines whether the GPU driver software is torn down after the last client * exits. * * This operation takes effect immediately. It is not persistent across reboots. After each reboot the * persistence mode is reset to "Disabled". * * See \ref nvmlEnableState_t for available modes. * * @param device The identifier of the target device * @param mode The target persistence mode * * @return * - \ref NVML_SUCCESS if the persistence mode was set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetPersistenceMode() */ nvmlReturn_t DECLDIR nvmlDeviceSetPersistenceMode nvmlDeviceSetPersistenceModeNr9ror0r;moderr/s rr r `s-B !!? @B V'- .CS rcT[S5nU"U[U55n[U5 g)a /** * Set the compute mode for the device. * * For all products. * Requires root/admin permissions. * * The compute mode determines whether a GPU can be used for compute operations and whether it can * be shared across contexts. * * This operation takes effect immediately. Under Linux it is not persistent across reboots and * always resets to "Default". Under windows it is persistent. * * Under windows compute mode may only be set to DEFAULT when running in WDDM * * See \ref nvmlComputeMode_t for details on available compute modes. * * @param device The identifier of the target device * @param mode The target compute mode * * @return * - \ref NVML_SUCCESS if the compute mode was set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetComputeMode() */ nvmlReturn_t DECLDIR nvmlDeviceSetComputeMode nvmlDeviceSetComputeModeN)r9rr0rs rrrs-D !!; 4}I !N OB VU9% &CS   ((rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves current clocks throttling reasons. * * For all fully supported products. * * \note More than one bit can be enabled at the same time. Multiple reasons can be affecting clocks at once. * * @param device The identifier of the target device * @param clocksThrottleReasons Reference in which to return bitmask of active clocks throttle * reasons * * @return * - \ref NVML_SUCCESS if \a clocksThrottleReasons has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clocksThrottleReasons is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlClocksThrottleReasons * @see nvmlDeviceGetSupportedClocksThrottleReasons */ nvmlReturn_t DECLDIR nvmlDeviceGetCurrentClocksThrottleReasons )nvmlDeviceGetCurrentClocksThrottleReasonsr4rQs rrTrTps>4}I !L MB VU9% &CS   ((rc[S5n[5nU"U[U55n[U5 [ UR 5$)a /** * Retrieves the NVML index of this device. * * For all products. * * Valid indices are derived from the \a accessibleDevices count returned by * \ref nvmlDeviceGetCount(). For example, if \a accessibleDevices is 2 the valid indices * are 0 and 1, corresponding to GPU 0 and GPU 1. * * The order in which NVML enumerates devices has no guarantees of consistency between reboots. For that reason it * is recommended that devices be looked up by their PCI ids or GPU UUID. See * \ref nvmlDeviceGetHandleByPciBusId() and \ref nvmlDeviceGetHandleByUUID(). * * Note: The NVML index may not correlate with other APIs, such as the CUDA device index. * * @param device The identifier of the target device * @param index Reference in which to return the NVML index of the device * * @return * - \ref NVML_SUCCESS if \a index has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a index is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetHandleByIndex() * @see nvmlDeviceGetCount() */ nvmlReturn_t DECLDIR nvmlDeviceGetIndex nvmlDeviceGetIndexrD)r;rrr/s rrVrVs>@ !!5 6BhG VU7^ $CS  &&rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Queries the state of per process accounting mode. * * For Kepler &tm; or newer fully supported devices. * * See \ref nvmlDeviceGetAccountingStats for more details. * See \ref nvmlDeviceSetAccountingMode * * @param device The identifier of the target device * @param mode Reference in which to return the current accounting mode * * @return * - \ref NVML_SUCCESS if the mode has been successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode are NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingMode nvmlDeviceGetAccountingModernrps rrXrXs>, !F !> ?B VU6] #CS  %%rcT[S5nU"U[U55n[U5 g)aU /** * Enables or disables per process accounting. * * For Kepler &tm; or newer fully supported devices. * Requires root/admin permissions. * * @note This setting is not persistent and will default to disabled after driver unloads. * Enable persistence mode to be sure the setting doesn't switch off to disabled. * * @note Enabling accounting mode has no negative impact on the GPU performance. * * @note Disabling accounting clears all accounting pids information. * * See \ref nvmlDeviceGetAccountingMode * See \ref nvmlDeviceGetAccountingStats * See \ref nvmlDeviceClearAccountingPids * * @param device The identifier of the target device * @param mode The target accounting mode * * @return * - \ref NVML_SUCCESS if the new mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device or \a mode are invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceSetAccountingMode nvmlDeviceSetAccountingModeNrrs rrZrZs-@ !!> ?B V'- .CS rc@[S5nU"U5n[U5 g)a /** * Clears accounting information about all processes that have already terminated. * * For Kepler &tm; or newer fully supported devices. * Requires root/admin permissions. * * See \ref nvmlDeviceGetAccountingMode * See \ref nvmlDeviceGetAccountingStats * See \ref nvmlDeviceSetAccountingMode * * @param device The identifier of the target device * * @return * - \ref NVML_SUCCESS if accounting information has been cleared * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device are invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceClearAccountingPids nvmlDeviceClearAccountingPidsNrUrVs rr\r\s#0 !!@ AB V*CS rc[5n[S5nU"U[U5[U55n[ U5 UR [ R:XaSUl[U5$)a /** * Queries process's accounting stats. * * For Kepler &tm; or newer fully supported devices. * * Accounting stats capture GPU utilization and other statistics across the lifetime of a process. * Accounting stats can be queried during life time of the process and after its termination. * The time field in \ref nvmlAccountingStats_t is reported as 0 during the lifetime of the process and * updated to actual running time after its termination. * Accounting stats are kept in a circular buffer, newly created processes overwrite information about old * processes. * * See \ref nvmlAccountingStats_t for description of each returned metric. * List of processes that can be queried can be retrieved from \ref nvmlDeviceGetAccountingPids. * * @note Accounting Mode needs to be on. See \ref nvmlDeviceGetAccountingMode. * @note Only compute and graphics applications stats can be queried. Monitoring applications stats can't be * queried since they don't contribute to GPU utilization. * @note In case of pid collision stats of only the latest process (that terminated last) will be reported * * @warning On Kepler devices per process statistics are accurate only if there's one process running on a GPU. * * @param device The identifier of the target device * @param pid Process Id of the target process to query stats for * @param stats Reference in which to return the process's accounting stats * * @return * - \ref NVML_SUCCESS if stats have been successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a stats are NULL * - \ref NVML_ERROR_NOT_FOUND if process stats were not found * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature or accounting mode is disabled * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetAccountingBufferSize */ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingStats nvmlDeviceGetAccountingStatsN) rr9rrr0rrrrU)r;rstatsrr/s rr^r^s^P $ %E !? @B VVC[%, /CS  B H HH#  rc[[U55n[UR-"5n[S5nU"U[ U5U5n[ U5 [ [[USUR55$)a /** * Queries list of processes that can be queried for accounting stats. The list of processes returned * can be in running or terminated state. * * For Kepler &tm; or newer fully supported devices. * * To just query the number of processes ready to be queried, call this function with *count = 0 and * pids=NULL. The return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if list is empty. * * For more details see \ref nvmlDeviceGetAccountingStats. * * @note In case of PID collision some processes might not be accessible before the circular buffer is full. * * @param device The identifier of the target device * @param count Reference in which to provide the \a pids array size, and * to return the number of elements ready to be queried * @param pids Reference in which to return list of process ids * * @return * - \ref NVML_SUCCESS if pids were successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a count is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature or accounting mode is disabled * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a count is too small (\a count is set to * expected value) * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetAccountingBufferSize */ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingPids nvmlDeviceGetAccountingPidsr) r!nvmlDeviceGetAccountingBufferSizerr9rr0listmapint)r;r~pidsrr/s rraraLshB 4V< =E U[[ #D !> ?B VU5\4 (CS Ca ,- ..rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Returns the number of processes that the circular buffer with accounting pids can hold. * * For Kepler &tm; or newer fully supported devices. * * This is the maximum number of processes that accounting information will be stored for before information * about oldest processes will get overwritten by information about new processes. * * @param device The identifier of the target device * @param bufferSize Reference in which to provide the size (in number of elements) * of the circular buffer for accounting stats. * * @return * - \ref NVML_SUCCESS if buffer size was successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a bufferSize is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature or accounting mode is disabled * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetAccountingStats * @see nvmlDeviceGetAccountingPids */ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingBufferSize rb)rr9rr0rer)r; bufferSizerr/s rrbrbus@4J !D EB VU:& 'CS z  rc[U5n[S5n[S5nU"X[U5S5nU[:waU[ :wa [ U5eURS-S-Ul[UR-nU"5nU"X[U5U5n[U5 [[[USUR55$)a /** * Returns the list of retired pages by source, including pages that are pending retirement * The address information provided from this API is the hardware address of the page that was retired. Note * that this does not match the virtual address used in CUDA, but will match the address information in XID 63 * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param cause Filter page addresses by cause of retirement * @param pageCount Reference in which to provide the \a addresses buffer size, and * to return the number of retired pages that match \a cause * Set to 0 to query the size without allocating an \a addresses buffer * @param addresses Buffer to write the page addresses into * * @return * - \ref NVML_SUCCESS if \a pageCount was populated and \a addresses was filled * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a pageCount indicates the buffer is not large enough to store all the * matching page addresses. \a pageCount is set to the needed size. * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a pageCount is NULL, \a cause is invalid, or * \a addresses is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetRetiredPages rnvmlDeviceGetRetiredPagesNrr) _nvmlPageRetirementCause_trr9rrrrrrr0rcrdre)r sourceFilterc_sourcerrr/ page_arrayc_pagess rrjrjs:*,7HQiG !< =B VuW~t 4C  , ,n MMA%)GMw}},JlG VuW~w 7CS C7==12 33rc[5n[S5nU"U[U55n[U5 [ UR 5$)a /** * Check if any pages are pending retirement and need a reboot to fully retire. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param isPending Reference in which to return the pending status * * @return * - \ref NVML_SUCCESS if \a isPending was populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a isPending is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetRetiredPagesPendingStatus &nvmlDeviceGetRetiredPagesPendingStatus)ror9rr0rer)r c_pendingrr/s rrqrqs?(#$I !I JB VU9% &CS y rc[5n[S5nU"U[U5[U55n[ U5 [ UR 5$)a /** * Retrieves the root/admin permissions on the target API. See \a nvmlRestrictedAPI_t for the list of supported APIs. * If an API is restricted only root users can call that API. See \a nvmlDeviceSetAPIRestriction to change current permissions. * * For all fully supported products. * * @param device The identifier of the target device * @param apiType Target API type for this operation * @param isRestricted Reference in which to return the current restriction * NVML_FEATURE_ENABLED indicates that the API is root-only * NVML_FEATURE_DISABLED indicates that the API is accessible to all users * * @return * - \ref NVML_SUCCESS if \a isRestricted has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a apiType incorrect or \a isRestricted is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device or the device does not support * the feature that is being queried (E.G. Enabling/disabling Auto Boosted clocks is * not supported by the device) * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlRestrictedAPI_t */ nvmlReturn_t DECLDIR nvmlDeviceGetAPIRestriction nvmlDeviceGetAPIRestriction)ror9_nvmlRestrictedAPI_trr0rer)rapiType c_permissionrr/s rrtrtsI8&'L !> ?B V)'2E,4G HCS |!! ""rch[S5nU"U[U5[U55n[U5 g)a /** * Changes the root/admin restructions on certain APIs. See \a nvmlRestrictedAPI_t for the list of supported APIs. * This method can be used by a root/admin user to give non-root/admin access to certain otherwise-restricted APIs. * The new setting lasts for the lifetime of the NVIDIA driver; it is not persistent. See \a nvmlDeviceGetAPIRestriction * to query the current restriction settings. * * For Kepler &tm; or newer fully supported devices. * Requires root/admin permissions. * * @param device The identifier of the target device * @param apiType Target API type for this operation * @param isRestricted The target restriction * * @return * - \ref NVML_SUCCESS if \a isRestricted has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a apiType incorrect * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support changing API restrictions or the device does not support * the feature that api restrictions are being set for (E.G. Enabling/disabling auto * boosted clocks is not supported by the device) * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlRestrictedAPI_t */ nvmlReturn_t DECLDIR nvmlDeviceSetAPIRestriction nvmlDeviceSetAPIRestrictionN)r9ruror0)r;rv isRestrictedrr/s rryrys4< !!> ?B V)'24F|4T UCS rc|[5n[S5nU"U[U55n[U5 [ U5$)a /** * Get Bridge Chip Information for all the bridge chips on the board. * * For all fully supported products. * Only applicable to multi-GPU products. * * @param device The identifier of the target device * @param bridgeHierarchy Reference to the returned bridge chip Hierarchy * * @return * - \ref NVML_SUCCESS if bridge chip exists * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a bridgeInfo is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if bridge chip not supported on the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * */ nvmlReturn_t DECLDIR nvmlDeviceGetBridgeChipInfo nvmlDeviceGetBridgeChipInfo)rr9rr0rU)r;bridgeHierarchyrr/s rr|r|,s;,23O !> ?B VU?+ ,CS  ((rc [U5n[U5n[S5n[5n[ S5nU"XU[ U5[ U5S5nU[ :wa [U5eUR[-n U "5n U"XU[ U5[ U5U 5n[U5 URU SUR4$)aJ /** * Gets recent samples for the GPU. * * For Kepler &tm; or newer fully supported devices. * * Based on type, this method can be used to fetch the power, utilization or clock samples maintained in the buffer by * the driver. * * Power, Utilization and Clock samples are returned as type "unsigned int" for the union nvmlValue_t. * * To get the size of samples that user needs to allocate, the method is invoked with samples set to NULL. * The returned samplesCount will provide the number of samples that can be queried. The user needs to * allocate the buffer with size as samplesCount * sizeof(nvmlSample_t). * * lastSeenTimeStamp represents CPU timestamp in microseconds. Set it to 0 to fetch all the samples maintained by the * underlying buffer. Set lastSeenTimeStamp to one of the timeStamps retrieved from the date of the previous query * to get more recent samples. * * This method fetches the number of entries which can be accommodated in the provided samples array, and the * reference samplesCount is updated to indicate how many samples were actually retrieved. The advantage of using this * method for samples in contrast to polling via existing methods is to get get higher frequency data at lower polling cost. * * @param device The identifier for the target device * @param type Type of sampling event * @param lastSeenTimeStamp Return only samples with timestamp greater than lastSeenTimeStamp. * @param sampleValType Output parameter to represent the type of sample value as described in nvmlSampleVal_t * @param sampleCount Reference to provide the number of elements which can be queried in samples array * @param samples Reference in which samples are returned * @return * - \ref NVML_SUCCESS if samples are successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a samplesCount is NULL or * reference to \a sampleCount is 0 for non null \a samples * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_NOT_FOUND if sample entries are not found * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetSamples rnvmlDeviceGetSamplesN) _nvmlSamplingType_trr_nvmlValueType_tr9rrrrrr0) r sampling_typerc_sampling_type c_time_stampc_sample_countc_sample_value_typerr/ sampleArray c_sampless rrrIsV*-8Oy)LAYN*, !7 8B VlE:M4NPUVdPegk lC |n &&7K I VlU;N5OQVWeQfhq rCS  % %y>3G3G'H IIrc[U5n[5n[S5nU"X[U55n[ U5 [ U5$)a /** * Gets the duration of time during which the device was throttled (lower than requested clocks) due to power * or thermal constraints. * * The method is important to users who are tying to understand if their GPUs throttle at any point during their applications. The * difference in violation times at two different reference times gives the indication of GPU throttling event. * * Violation for thermal capping is not supported at this time. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param perfPolicyType Represents Performance policy which can trigger GPU throttling * @param violTime Reference to which violation time related information is returned * * * @return * - \ref NVML_SUCCESS if violation time is successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a perfPolicyType is invalid, or \a violTime is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * */ nvmlReturn_t DECLDIR nvmlDeviceGetViolationStatus nvmlDeviceGetViolationStatus)_nvmlPerfPolicyType_trr9rr0rU)rperfPolicyTypec_perfPolicy_type c_violTimerr/s rrrsH8.n=&(J !? @B Vj(9 :CS  ##rc[5n[S5nU"U[U5[U55n[ U5 [ UR 5$)a /** * Retrieve PCIe utilization information. * This function is querying a byte counter over a 20ms interval and thus is the * PCIe throughput over that interval. * * For Maxwell &tm; or newer fully supported devices. * * This method is not supported in virtual machines running virtual GPU (vGPU). * * @param device The identifier of the target device * @param counter The specific counter that should be queried \ref nvmlPcieUtilCounter_t * @param value Reference in which to return throughput in KB/s * * @return * - \ref NVML_SUCCESS if \a value has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device or \a counter is invalid, or \a value is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPcieThroughput nvmlDeviceGetPcieThroughput)rr9_nvmlPcieUtilCounter_trr0rUr)rcounterrrr/s rrrsE2XF !> ?B V+G4eFm DCS  %%rcH[S5n[S5nU"U[U5S5nU[:wa [ U5e[ UR 5 [UR -nU"5nU"U[U5U5n[U5 [USUR 5$)a~ /** * Retrieve the set of GPUs that have a CPU affinity with the given CPU number * For all products. * Supported on Linux only. * * @param cpuNumber The CPU number * @param count When zero, is set to the number of matching GPUs such that \a deviceArray * can be malloc'd. When non-zero, \a deviceArray will be filled with \a count * number of device handles. * @param deviceArray An array of device handles for GPUs found with affinity to \a cpuNumber * * @return * - \ref NVML_SUCCESS if \a deviceArray or \a count (if initially zero) has been set * - \ref NVML_ERROR_INVALID_ARGUMENT if \a cpuNumber, or \a count is invalid, or \a deviceArray is NULL with a non-zero \a count * - \ref NVML_ERROR_NOT_SUPPORTED if the device or OS does not support this feature * - \ref NVML_ERROR_UNKNOWN an error has occurred in underlying topology discovery */ nvmlReturn_t DECLDIR nvmlSystemGetTopologyGpuSet rnvmlSystemGetTopologyGpuSetN) rr9rrrprintrrr0rc) cpuNumberrrr/r#r$s rrrs*QiG !> ?B Yg -C ln '--!GMM1LI Yg 2CS  !GMM* ++rc[S5n[S5nU"X[U5S5nU[:wa [ U5e[ UR -nU"5nU"X[U5U5n[U5 [USUR 5$)a /** * Retrieve the set of GPUs that are nearest to a given device at a specific interconnectivity level * For all products. * Supported on Linux only. * * @param device The identifier of the first device * @param level The \ref nvmlGpuTopologyLevel_t level to search for other GPUs * @param count When zero, is set to the number of matching GPUs such that \a deviceArray * can be malloc'd. When non-zero, \a deviceArray will be filled with \a count * number of device handles. * @param deviceArray An array of device handles for GPUs found at \a level * * @return * - \ref NVML_SUCCESS if \a deviceArray or \a count (if initially zero) has been set * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device, \a level, or \a count is invalid, or \a deviceArray is NULL with a non-zero \a count * - \ref NVML_ERROR_NOT_SUPPORTED if the device or OS does not support this feature * - \ref NVML_ERROR_UNKNOWN an error has occurred in underlying topology discovery */ nvmlReturn_t DECLDIR nvmlDeviceGetTopologyNearestGpus r nvmlDeviceGetTopologyNearestGpusN) rr9rrrrrr0rc)rlevelrrr/r#r$s rrrs,QiG !C DB VE'ND 1C ln"GMM1LI VE'NI 6CS  !GMM* ++rc[5n[S5nU"X[U55n[U5 [ UR 5$)a@ /** * Retrieve the common ancestor for two devices * For all products. * Supported on Linux only. * * @param device1 The identifier of the first device * @param device2 The identifier of the second device * @param pathInfo A \ref nvmlGpuTopologyLevel_t that gives the path type * * @return * - \ref NVML_SUCCESS if \a pathInfo has been set * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device1, or \a device2 is invalid, or \a pathInfo is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device or OS does not support this feature * - \ref NVML_ERROR_UNKNOWN an error has occurred in underlying topology discovery */ nvmlReturn_t DECLDIR nvmlDeviceGetTopologyCommonAncestor #nvmlDeviceGetTopologyCommonAncestor)_nvmlGpuTopologyLevel_tr9rr0rUr)device1device2c_levelrr/s rrrs>&&'G !F GB WuW~ .CS  &&r(ctypesrrr threadingr enumrrorrrrDrrrr r!r"r#r$rrr)r*r+r,r-r&rr1r2r/rr6r7r8r9r:r4rr?r@rArBrCrDrErFrGrHr=_nvmlEccBitType_tNVML_SINGLE_BIT_ECCNVML_DOUBLE_BIT_ECCNVML_ECC_ERROR_TYPE_COUNTrrLrMrNrJrrRrSrTrPr|rXrYrZr[r\rVrr`rar^rrmrnrorprqrrrsrtrurvrwrxryrzr{r|r}rkrbrrrrr _nvmlReturn_trrrrrrrrrrrrrrrrrrrrrrrrrryrrrrorrrrrrrrrkrrrrrurrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrnvmlFlagDefault nvmlFlagForcerar^rrr:rHr"NVML_DEVICE_PCI_BUS_ID_BUFFER_SIZErrNVML_VALUE_NOT_AVAILABLE_uintr5Lockr3rrrr-r0rr2r9objectr;rIrL StructurerNPOINTERr rUrWrdrkrqrwr{rrrrrrrrrrrUnionrrrrr-nvmlEventTypeSingleBitEccErrornvmlEventTypeDoubleBitEccErrornvmlEventTypePStatenvmlEventTypeXidCriticalErrornvmlEventTypeClocknvmlEventTypeNonenvmlEventTypeAllnvmlClocksThrottleReasonGpuIdle1nvmlClocksThrottleReasonApplicationsClocksSetting)nvmlClocksThrottleReasonUserDefinedClocks"nvmlClocksThrottleReasonSwPowerCap"nvmlClocksThrottleReasonHwSlowdownnvmlClocksThrottleReasonUnknownnvmlClocksThrottleReasonNonenvmlClocksThrottleReasonAllrrrrrrrrrrrr rrrrrr!r r'r*r,r0r7r9r=r@rCrGrJrOrTrXrZr]r`rerhrkrmrsrurxrzrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrr r%r'r*r,r0r3r7r;r=rCrHrJrNrPrTrVrXrZr\r^rarbrjrqrtryr|rrrrrrr rrrs @   d &&'#&'#%&"%&"#$ )$)$#t $%!%&" ! !%&"%&"&'##$  #4 # $4 $ #$ %&" %D%, d          D. $   !"  ! ! "! %'"$&!K4K\44! 4 $23/<=9#$  ) )-.*./+ "$ "#4#   !%&"#$ d #$  $&!%'" 4 B "#    8 4!T2 +-'!)+&')$!!#(*%%'"%0_" &r  nn 0) 0)f>8!%2'' ) *+ G)GD**)-/ I ./'0"("","&&-&0"50#-#+E(/ i 23%7%7%7%7%7%7(9(F)G(F)G)<)<); ); )F )F-?4F14e),>",>",>,>/K/N0O/`0a0R0R0R 0R 0O 0O$+$ 1 .b""J F)6&<)8)Z$'L1f( T0!d, \0&d,"^ '2#j2'hg RK Z9 vC J&>$B*8&6(@$@+>80.6&B%)P!)H*@0&>&D 'D 6'<'B':'>3l4l'>&:&:(<(8$*L'B0>':':'>5D44"B'>&<#5L++&'R-"`*'X >2828(4"5J//)>ENEN#9N"H$L%N#J'R.`$N$P.b F F$N4+\,@%P0$:#6#<%6%<)B)B$'P&:#L