Struct nvml_wrapper_sys::bindings::NvmlLib

pub struct NvmlLib {

    pub __library: Library,
    pub nvmlInit_v2: Result<unsafe extern "C" fn() -> nvmlReturn_t, Error>,
    pub nvmlInitWithFlags: Result<unsafe extern "C" fn(flags: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlShutdown: Result<unsafe extern "C" fn() -> nvmlReturn_t, Error>,
    pub nvmlErrorString: Result<unsafe extern "C" fn(result: nvmlReturn_t) -> *const c_char, Error>,
    pub nvmlSystemGetDriverVersion: Result<unsafe extern "C" fn(version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetNVMLVersion: Result<unsafe extern "C" fn(version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetCudaDriverVersion: Result<unsafe extern "C" fn(cudaDriverVersion: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetCudaDriverVersion_v2: Result<unsafe extern "C" fn(cudaDriverVersion: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetProcessName: Result<unsafe extern "C" fn(pid: c_uint, name: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlUnitGetCount: Result<unsafe extern "C" fn(unitCount: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlUnitGetHandleByIndex: Result<unsafe extern "C" fn(index: c_uint, unit: *mut nvmlUnit_t) -> nvmlReturn_t, Error>,
    pub nvmlUnitGetUnitInfo: Result<unsafe extern "C" fn(unit: nvmlUnit_t, info: *mut nvmlUnitInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlUnitGetLedState: Result<unsafe extern "C" fn(unit: nvmlUnit_t, state: *mut nvmlLedState_t) -> nvmlReturn_t, Error>,
    pub nvmlUnitGetPsuInfo: Result<unsafe extern "C" fn(unit: nvmlUnit_t, psu: *mut nvmlPSUInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlUnitGetTemperature: Result<unsafe extern "C" fn(unit: nvmlUnit_t, type_: c_uint, temp: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlUnitGetFanSpeedInfo: Result<unsafe extern "C" fn(unit: nvmlUnit_t, fanSpeeds: *mut nvmlUnitFanSpeeds_t) -> nvmlReturn_t, Error>,
    pub nvmlUnitGetDevices: Result<unsafe extern "C" fn(unit: nvmlUnit_t, deviceCount: *mut c_uint, devices: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetHicVersion: Result<unsafe extern "C" fn(hwbcCount: *mut c_uint, hwbcEntries: *mut nvmlHwbcEntry_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCount_v2: Result<unsafe extern "C" fn(deviceCount: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetAttributes_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, attributes: *mut nvmlDeviceAttributes_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetHandleByIndex_v2: Result<unsafe extern "C" fn(index: c_uint, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetHandleBySerial: Result<unsafe extern "C" fn(serial: *const c_char, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetHandleByUUID: Result<unsafe extern "C" fn(uuid: *const c_char, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetHandleByPciBusId_v2: Result<unsafe extern "C" fn(pciBusId: *const c_char, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetName: Result<unsafe extern "C" fn(device: nvmlDevice_t, name: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetBrand: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: *mut nvmlBrandType_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetIndex: Result<unsafe extern "C" fn(device: nvmlDevice_t, index: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSerial: Result<unsafe extern "C" fn(device: nvmlDevice_t, serial: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetModuleId: Result<unsafe extern "C" fn(device: nvmlDevice_t, moduleId: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMemoryAffinity: Result<unsafe extern "C" fn(device: nvmlDevice_t, nodeSetSize: c_uint, nodeSet: *mut c_ulong, scope: nvmlAffinityScope_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCpuAffinityWithinScope: Result<unsafe extern "C" fn(device: nvmlDevice_t, cpuSetSize: c_uint, cpuSet: *mut c_ulong, scope: nvmlAffinityScope_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCpuAffinity: Result<unsafe extern "C" fn(device: nvmlDevice_t, cpuSetSize: c_uint, cpuSet: *mut c_ulong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetCpuAffinity: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceClearCpuAffinity: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetTopologyCommonAncestor: Result<unsafe extern "C" fn(device1: nvmlDevice_t, device2: nvmlDevice_t, pathInfo: *mut nvmlGpuTopologyLevel_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetTopologyNearestGpus: Result<unsafe extern "C" fn(device: nvmlDevice_t, level: nvmlGpuTopologyLevel_t, count: *mut c_uint, deviceArray: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetTopologyGpuSet: Result<unsafe extern "C" fn(cpuNumber: c_uint, count: *mut c_uint, deviceArray: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetP2PStatus: Result<unsafe extern "C" fn(device1: nvmlDevice_t, device2: nvmlDevice_t, p2pIndex: nvmlGpuP2PCapsIndex_t, p2pStatus: *mut nvmlGpuP2PStatus_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetUUID: Result<unsafe extern "C" fn(device: nvmlDevice_t, uuid: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetMdevUUID: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, mdevUuid: *mut c_char, size: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMinorNumber: Result<unsafe extern "C" fn(device: nvmlDevice_t, minorNumber: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetBoardPartNumber: Result<unsafe extern "C" fn(device: nvmlDevice_t, partNumber: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetInforomVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, object: nvmlInforomObject_t, version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetInforomImageVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetInforomConfigurationChecksum: Result<unsafe extern "C" fn(device: nvmlDevice_t, checksum: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceValidateInforom: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDisplayMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, display: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDisplayActive: Result<unsafe extern "C" fn(device: nvmlDevice_t, isActive: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPersistenceMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPciInfo_v3: Result<unsafe extern "C" fn(device: nvmlDevice_t, pci: *mut nvmlPciInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMaxPcieLinkGeneration: Result<unsafe extern "C" fn(device: nvmlDevice_t, maxLinkGen: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuMaxPcieLinkGeneration: Result<unsafe extern "C" fn(device: nvmlDevice_t, maxLinkGenDevice: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMaxPcieLinkWidth: Result<unsafe extern "C" fn(device: nvmlDevice_t, maxLinkWidth: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCurrPcieLinkGeneration: Result<unsafe extern "C" fn(device: nvmlDevice_t, currLinkGen: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCurrPcieLinkWidth: Result<unsafe extern "C" fn(device: nvmlDevice_t, currLinkWidth: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPcieThroughput: Result<unsafe extern "C" fn(device: nvmlDevice_t, counter: nvmlPcieUtilCounter_t, value: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPcieReplayCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, value: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetClockInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: nvmlClockType_t, clock: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMaxClockInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: nvmlClockType_t, clock: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpcClkVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, offset: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetApplicationsClock: Result<unsafe extern "C" fn(device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDefaultApplicationsClock: Result<unsafe extern "C" fn(device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceResetApplicationsClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetClock: Result<unsafe extern "C" fn(device: nvmlDevice_t, clockType: nvmlClockType_t, clockId: nvmlClockId_t, clockMHz: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMaxCustomerBoostClock: Result<unsafe extern "C" fn(device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSupportedMemoryClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, count: *mut c_uint, clocksMHz: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSupportedGraphicsClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, memoryClockMHz: c_uint, count: *mut c_uint, clocksMHz: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetAutoBoostedClocksEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, isEnabled: *mut nvmlEnableState_t, defaultIsEnabled: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetAutoBoostedClocksEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, enabled: nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetDefaultAutoBoostedClocksEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, enabled: nvmlEnableState_t, flags: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetFanSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, speed: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetFanSpeed_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, speed: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetTargetFanSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, targetSpeed: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetDefaultFanSpeed_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMinMaxFanSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, minSpeed: *mut c_uint, maxSpeed: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetFanControlPolicy_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, policy: *mut nvmlFanControlPolicy_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetFanControlPolicy: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, policy: nvmlFanControlPolicy_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNumFans: Result<unsafe extern "C" fn(device: nvmlDevice_t, numFans: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetTemperature: Result<unsafe extern "C" fn(device: nvmlDevice_t, sensorType: nvmlTemperatureSensors_t, temp: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetTemperatureThreshold: Result<unsafe extern "C" fn(device: nvmlDevice_t, thresholdType: nvmlTemperatureThresholds_t, temp: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetTemperatureThreshold: Result<unsafe extern "C" fn(device: nvmlDevice_t, thresholdType: nvmlTemperatureThresholds_t, temp: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetThermalSettings: Result<unsafe extern "C" fn(device: nvmlDevice_t, sensorIndex: c_uint, pThermalSettings: *mut nvmlGpuThermalSettings_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPerformanceState: Result<unsafe extern "C" fn(device: nvmlDevice_t, pState: *mut nvmlPstates_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCurrentClocksEventReasons: Result<unsafe extern "C" fn(device: nvmlDevice_t, clocksEventReasons: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCurrentClocksThrottleReasons: Result<unsafe extern "C" fn(device: nvmlDevice_t, clocksThrottleReasons: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSupportedClocksEventReasons: Result<unsafe extern "C" fn(device: nvmlDevice_t, supportedClocksEventReasons: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSupportedClocksThrottleReasons: Result<unsafe extern "C" fn(device: nvmlDevice_t, supportedClocksThrottleReasons: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPowerState: Result<unsafe extern "C" fn(device: nvmlDevice_t, pState: *mut nvmlPstates_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDynamicPstatesInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, pDynamicPstatesInfo: *mut nvmlGpuDynamicPstatesInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMemClkVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, offset: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMinMaxClockOfPState: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: nvmlClockType_t, pstate: nvmlPstates_t, minClockMHz: *mut c_uint, maxClockMHz: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSupportedPerformanceStates: Result<unsafe extern "C" fn(device: nvmlDevice_t, pstates: *mut nvmlPstates_t, size: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpcClkMinMaxVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, minOffset: *mut c_int, maxOffset: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMemClkMinMaxVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, minOffset: *mut c_int, maxOffset: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPowerManagementMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPowerManagementLimit: Result<unsafe extern "C" fn(device: nvmlDevice_t, limit: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPowerManagementLimitConstraints: Result<unsafe extern "C" fn(device: nvmlDevice_t, minLimit: *mut c_uint, maxLimit: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPowerManagementDefaultLimit: Result<unsafe extern "C" fn(device: nvmlDevice_t, defaultLimit: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPowerUsage: Result<unsafe extern "C" fn(device: nvmlDevice_t, power: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetTotalEnergyConsumption: Result<unsafe extern "C" fn(device: nvmlDevice_t, energy: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetEnforcedPowerLimit: Result<unsafe extern "C" fn(device: nvmlDevice_t, limit: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuOperationMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, current: *mut nvmlGpuOperationMode_t, pending: *mut nvmlGpuOperationMode_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMemoryInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, memory: *mut nvmlMemory_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMemoryInfo_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, memory: *mut nvmlMemory_v2_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetComputeMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: *mut nvmlComputeMode_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCudaComputeCapability: Result<unsafe extern "C" fn(device: nvmlDevice_t, major: *mut c_int, minor: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetEccMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, current: *mut nvmlEnableState_t, pending: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDefaultEccMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, defaultMode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetBoardId: Result<unsafe extern "C" fn(device: nvmlDevice_t, boardId: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMultiGpuBoard: Result<unsafe extern "C" fn(device: nvmlDevice_t, multiGpuBool: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetTotalEccErrors: Result<unsafe extern "C" fn(device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, eccCounts: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDetailedEccErrors: Result<unsafe extern "C" fn(device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, eccCounts: *mut nvmlEccErrorCounts_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMemoryErrorCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, locationType: nvmlMemoryLocation_t, count: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetUtilizationRates: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut nvmlUtilization_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetEncoderUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetEncoderCapacity: Result<unsafe extern "C" fn(device: nvmlDevice_t, encoderQueryType: nvmlEncoderType_t, encoderCapacity: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetEncoderStats: Result<unsafe extern "C" fn(device: nvmlDevice_t, sessionCount: *mut c_uint, averageFps: *mut c_uint, averageLatency: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetEncoderSessions: Result<unsafe extern "C" fn(device: nvmlDevice_t, sessionCount: *mut c_uint, sessionInfos: *mut nvmlEncoderSessionInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDecoderUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetJpgUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetOfaUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetFBCStats: Result<unsafe extern "C" fn(device: nvmlDevice_t, fbcStats: *mut nvmlFBCStats_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetFBCSessions: Result<unsafe extern "C" fn(device: nvmlDevice_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlFBCSessionInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDriverModel: Result<unsafe extern "C" fn(device: nvmlDevice_t, current: *mut nvmlDriverModel_t, pending: *mut nvmlDriverModel_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVbiosVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetBridgeChipInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, bridgeHierarchy: *mut nvmlBridgeChipHierarchy_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetComputeRunningProcesses_v3: Result<unsafe extern "C" fn(device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGraphicsRunningProcesses_v3: Result<unsafe extern "C" fn(device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMPSComputeRunningProcesses_v3: Result<unsafe extern "C" fn(device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetRunningProcessDetailList: Result<unsafe extern "C" fn(device: nvmlDevice_t, plist: *mut nvmlProcessDetailList_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceOnSameBoard: Result<unsafe extern "C" fn(device1: nvmlDevice_t, device2: nvmlDevice_t, onSameBoard: *mut c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetAPIRestriction: Result<unsafe extern "C" fn(device: nvmlDevice_t, apiType: nvmlRestrictedAPI_t, isRestricted: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSamples: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: nvmlSamplingType_t, lastSeenTimeStamp: c_ulonglong, sampleValType: *mut nvmlValueType_t, sampleCount: *mut c_uint, samples: *mut nvmlSample_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetBAR1MemoryInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, bar1Memory: *mut nvmlBAR1Memory_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetViolationStatus: Result<unsafe extern "C" fn(device: nvmlDevice_t, perfPolicyType: nvmlPerfPolicyType_t, violTime: *mut nvmlViolationTime_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetIrqNum: Result<unsafe extern "C" fn(device: nvmlDevice_t, irqNum: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNumGpuCores: Result<unsafe extern "C" fn(device: nvmlDevice_t, numCores: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPowerSource: Result<unsafe extern "C" fn(device: nvmlDevice_t, powerSource: *mut nvmlPowerSource_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMemoryBusWidth: Result<unsafe extern "C" fn(device: nvmlDevice_t, busWidth: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPcieLinkMaxSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, maxSpeed: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPcieSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, pcieSpeed: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetAdaptiveClockInfoStatus: Result<unsafe extern "C" fn(device: nvmlDevice_t, adaptiveClockStatus: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetBusType: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: *mut nvmlBusType_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuFabricInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpuFabricInfo: *mut nvmlGpuFabricInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetConfComputeCapabilities: Result<unsafe extern "C" fn(capabilities: *mut nvmlConfComputeSystemCaps_t) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetConfComputeState: Result<unsafe extern "C" fn(state: *mut nvmlConfComputeSystemState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetConfComputeMemSizeInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, memInfo: *mut nvmlConfComputeMemSizeInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetConfComputeGpusReadyState: Result<unsafe extern "C" fn(isAcceptingWork: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetConfComputeProtectedMemoryUsage: Result<unsafe extern "C" fn(device: nvmlDevice_t, memory: *mut nvmlMemory_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetConfComputeGpuCertificate: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpuCert: *mut nvmlConfComputeGpuCertificate_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetConfComputeGpuAttestationReport: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpuAtstReport: *mut nvmlConfComputeGpuAttestationReport_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetAccountingMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetAccountingStats: Result<unsafe extern "C" fn(device: nvmlDevice_t, pid: c_uint, stats: *mut nvmlAccountingStats_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetAccountingPids: Result<unsafe extern "C" fn(device: nvmlDevice_t, count: *mut c_uint, pids: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetAccountingBufferSize: Result<unsafe extern "C" fn(device: nvmlDevice_t, bufferSize: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetRetiredPages: Result<unsafe extern "C" fn(device: nvmlDevice_t, cause: nvmlPageRetirementCause_t, pageCount: *mut c_uint, addresses: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetRetiredPages_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, cause: nvmlPageRetirementCause_t, pageCount: *mut c_uint, addresses: *mut c_ulonglong, timestamps: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetRetiredPagesPendingStatus: Result<unsafe extern "C" fn(device: nvmlDevice_t, isPending: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetRemappedRows: Result<unsafe extern "C" fn(device: nvmlDevice_t, corrRows: *mut c_uint, uncRows: *mut c_uint, isPending: *mut c_uint, failureOccurred: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetRowRemapperHistogram: Result<unsafe extern "C" fn(device: nvmlDevice_t, values: *mut nvmlRowRemapperHistogramValues_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetArchitecture: Result<unsafe extern "C" fn(device: nvmlDevice_t, arch: *mut nvmlDeviceArchitecture_t) -> nvmlReturn_t, Error>,
    pub nvmlUnitSetLedState: Result<unsafe extern "C" fn(unit: nvmlUnit_t, color: nvmlLedColor_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetPersistenceMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetComputeMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: nvmlComputeMode_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetEccMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, ecc: nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceClearEccErrorCounts: Result<unsafe extern "C" fn(device: nvmlDevice_t, counterType: nvmlEccCounterType_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetDriverModel: Result<unsafe extern "C" fn(device: nvmlDevice_t, driverModel: nvmlDriverModel_t, flags: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetGpuLockedClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, minGpuClockMHz: c_uint, maxGpuClockMHz: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceResetGpuLockedClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetMemoryLockedClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, minMemClockMHz: c_uint, maxMemClockMHz: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceResetMemoryLockedClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetApplicationsClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, memClockMHz: c_uint, graphicsClockMHz: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetClkMonStatus: Result<unsafe extern "C" fn(device: nvmlDevice_t, status: *mut nvmlClkMonStatus_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetPowerManagementLimit: Result<unsafe extern "C" fn(device: nvmlDevice_t, limit: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetGpuOperationMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: nvmlGpuOperationMode_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetAPIRestriction: Result<unsafe extern "C" fn(device: nvmlDevice_t, apiType: nvmlRestrictedAPI_t, isRestricted: nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetFanSpeed_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, speed: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetGpcClkVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, offset: c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetMemClkVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, offset: c_int) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetConfComputeUnprotectedMemSize: Result<unsafe extern "C" fn(device: nvmlDevice_t, sizeKiB: c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlSystemSetConfComputeGpusReadyState: Result<unsafe extern "C" fn(isAcceptingWork: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetAccountingMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceClearAccountingPids: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNvLinkState: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, isActive: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNvLinkVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, version: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNvLinkCapability: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, capability: nvmlNvLinkCapability_t, capResult: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNvLinkRemotePciInfo_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, pci: *mut nvmlPciInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNvLinkErrorCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: nvmlNvLinkErrorCounter_t, counterValue: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceResetNvLinkErrorCounters: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetNvLinkUtilizationControl: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint, control: *mut nvmlNvLinkUtilizationControl_t, reset: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNvLinkUtilizationControl: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint, control: *mut nvmlNvLinkUtilizationControl_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNvLinkUtilizationCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint, rxcounter: *mut c_ulonglong, txcounter: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceFreezeNvLinkUtilizationCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint, freeze: nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceResetNvLinkUtilizationCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetNvLinkRemoteDeviceType: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, pNvLinkDeviceType: *mut nvmlIntNvLinkDeviceType_t) -> nvmlReturn_t, Error>,
    pub nvmlEventSetCreate: Result<unsafe extern "C" fn(set: *mut nvmlEventSet_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceRegisterEvents: Result<unsafe extern "C" fn(device: nvmlDevice_t, eventTypes: c_ulonglong, set: nvmlEventSet_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSupportedEventTypes: Result<unsafe extern "C" fn(device: nvmlDevice_t, eventTypes: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlEventSetWait_v2: Result<unsafe extern "C" fn(set: nvmlEventSet_t, data: *mut nvmlEventData_t, timeoutms: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlEventSetFree: Result<unsafe extern "C" fn(set: nvmlEventSet_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceModifyDrainState: Result<unsafe extern "C" fn(pciInfo: *mut nvmlPciInfo_t, newState: nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceQueryDrainState: Result<unsafe extern "C" fn(pciInfo: *mut nvmlPciInfo_t, currentState: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceRemoveGpu_v2: Result<unsafe extern "C" fn(pciInfo: *mut nvmlPciInfo_t, gpuState: nvmlDetachGpuState_t, linkState: nvmlPcieLinkState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceDiscoverGpus: Result<unsafe extern "C" fn(pciInfo: *mut nvmlPciInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetFieldValues: Result<unsafe extern "C" fn(device: nvmlDevice_t, valuesCount: c_int, values: *mut nvmlFieldValue_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceClearFieldValues: Result<unsafe extern "C" fn(device: nvmlDevice_t, valuesCount: c_int, values: *mut nvmlFieldValue_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVirtualizationMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, pVirtualMode: *mut nvmlGpuVirtualizationMode_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetHostVgpuMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, pHostVgpuMode: *mut nvmlHostVgpuMode_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetVirtualizationMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, virtualMode: nvmlGpuVirtualizationMode_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGridLicensableFeatures_v4: Result<unsafe extern "C" fn(device: nvmlDevice_t, pGridLicensableFeatures: *mut nvmlGridLicensableFeatures_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetProcessUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut nvmlProcessUtilizationSample_t, processSamplesCount: *mut c_uint, lastSeenTimeStamp: c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGspFirmwareVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, version: *mut c_char) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGspFirmwareMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, isEnabled: *mut c_uint, defaultMode: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlGetVgpuDriverCapabilities: Result<unsafe extern "C" fn(capability: nvmlVgpuDriverCapability_t, capResult: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVgpuCapabilities: Result<unsafe extern "C" fn(device: nvmlDevice_t, capability: nvmlDeviceVgpuCapability_t, capResult: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetSupportedVgpus: Result<unsafe extern "C" fn(device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuTypeIds: *mut nvmlVgpuTypeId_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetCreatableVgpus: Result<unsafe extern "C" fn(device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuTypeIds: *mut nvmlVgpuTypeId_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetClass: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeClass: *mut c_char, size: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetName: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeName: *mut c_char, size: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetGpuInstanceProfileId: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, gpuInstanceProfileId: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetDeviceID: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, deviceID: *mut c_ulonglong, subsystemID: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetFramebufferSize: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, fbSize: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetNumDisplayHeads: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, numDisplayHeads: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetResolution: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, displayIndex: c_uint, xdim: *mut c_uint, ydim: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetLicense: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeLicenseString: *mut c_char, size: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetFrameRateLimit: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, frameRateLimit: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetMaxInstances: Result<unsafe extern "C" fn(device: nvmlDevice_t, vgpuTypeId: nvmlVgpuTypeId_t, vgpuInstanceCount: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetMaxInstancesPerVm: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, vgpuInstanceCountPerVm: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetActiveVgpus: Result<unsafe extern "C" fn(device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuInstances: *mut nvmlVgpuInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetVmID: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, vmId: *mut c_char, size: c_uint, vmIdType: *mut nvmlVgpuVmIdType_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetUUID: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, uuid: *mut c_char, size: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetVmDriverVersion: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetFbUsage: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, fbUsage: *mut c_ulonglong) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetLicenseStatus: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, licensed: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetType: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, vgpuTypeId: *mut nvmlVgpuTypeId_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetFrameRateLimit: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, frameRateLimit: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetEccMode: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, eccMode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetEncoderCapacity: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, encoderCapacity: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceSetEncoderCapacity: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, encoderCapacity: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetEncoderStats: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, averageFps: *mut c_uint, averageLatency: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetEncoderSessions: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlEncoderSessionInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetFBCStats: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, fbcStats: *mut nvmlFBCStats_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetFBCSessions: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlFBCSessionInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetGpuInstanceId: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, gpuInstanceId: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetGpuPciId: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, vgpuPciId: *mut c_char, length: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuTypeGetCapabilities: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, capability: nvmlVgpuCapability_t, capResult: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetMetadata: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, vgpuMetadata: *mut nvmlVgpuMetadata_t, bufferSize: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVgpuMetadata: Result<unsafe extern "C" fn(device: nvmlDevice_t, pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, bufferSize: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlGetVgpuCompatibility: Result<unsafe extern "C" fn(vgpuMetadata: *mut nvmlVgpuMetadata_t, pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, compatibilityInfo: *mut nvmlVgpuPgpuCompatibility_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetPgpuMetadataString: Result<unsafe extern "C" fn(device: nvmlDevice_t, pgpuMetadata: *mut c_char, bufferSize: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVgpuSchedulerLog: Result<unsafe extern "C" fn(device: nvmlDevice_t, pSchedulerLog: *mut nvmlVgpuSchedulerLog_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVgpuSchedulerState: Result<unsafe extern "C" fn(device: nvmlDevice_t, pSchedulerState: *mut nvmlVgpuSchedulerGetState_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVgpuSchedulerCapabilities: Result<unsafe extern "C" fn(device: nvmlDevice_t, pCapabilities: *mut nvmlVgpuSchedulerCapabilities_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetVgpuSchedulerState: Result<unsafe extern "C" fn(device: nvmlDevice_t, pSchedulerState: *mut nvmlVgpuSchedulerSetState_t) -> nvmlReturn_t, Error>,
    pub nvmlGetVgpuVersion: Result<unsafe extern "C" fn(supported: *mut nvmlVgpuVersion_t, current: *mut nvmlVgpuVersion_t) -> nvmlReturn_t, Error>,
    pub nvmlSetVgpuVersion: Result<unsafe extern "C" fn(vgpuVersion: *mut nvmlVgpuVersion_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVgpuUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, lastSeenTimeStamp: c_ulonglong, sampleValType: *mut nvmlValueType_t, vgpuInstanceSamplesCount: *mut c_uint, utilizationSamples: *mut nvmlVgpuInstanceUtilizationSample_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetVgpuProcessUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, lastSeenTimeStamp: c_ulonglong, vgpuProcessSamplesCount: *mut c_uint, utilizationSamples: *mut nvmlVgpuProcessUtilizationSample_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetAccountingMode: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, mode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetAccountingPids: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, count: *mut c_uint, pids: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetAccountingStats: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, pid: c_uint, stats: *mut nvmlAccountingStats_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceClearAccountingPids: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlVgpuInstanceGetLicenseInfo_v2: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, licenseInfo: *mut nvmlVgpuLicenseInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlGetExcludedDeviceCount: Result<unsafe extern "C" fn(deviceCount: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlGetExcludedDeviceInfoByIndex: Result<unsafe extern "C" fn(index: c_uint, info: *mut nvmlExcludedDeviceInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetMigMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: c_uint, activationStatus: *mut nvmlReturn_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMigMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, currentMode: *mut c_uint, pendingMode: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuInstanceProfileInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, profile: c_uint, info: *mut nvmlGpuInstanceProfileInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuInstanceProfileInfoV: Result<unsafe extern "C" fn(device: nvmlDevice_t, profile: c_uint, info: *mut nvmlGpuInstanceProfileInfo_v2_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuInstancePossiblePlacements_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, placements: *mut nvmlGpuInstancePlacement_t, count: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuInstanceRemainingCapacity: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, count: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceCreateGpuInstance: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, gpuInstance: *mut nvmlGpuInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceCreateGpuInstanceWithPlacement: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, placement: *const nvmlGpuInstancePlacement_t, gpuInstance: *mut nvmlGpuInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceDestroy: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuInstances: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, gpuInstances: *mut nvmlGpuInstance_t, count: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuInstanceById: Result<unsafe extern "C" fn(device: nvmlDevice_t, id: c_uint, gpuInstance: *mut nvmlGpuInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceGetInfo: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, info: *mut nvmlGpuInstanceInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceGetComputeInstanceProfileInfo: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profile: c_uint, engProfile: c_uint, info: *mut nvmlComputeInstanceProfileInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceGetComputeInstanceProfileInfoV: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profile: c_uint, engProfile: c_uint, info: *mut nvmlComputeInstanceProfileInfo_v2_t) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceGetComputeInstanceRemainingCapacity: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, count: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceGetComputeInstancePossiblePlacements: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, placements: *mut nvmlComputeInstancePlacement_t, count: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceCreateComputeInstance: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, computeInstance: *mut nvmlComputeInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceCreateComputeInstanceWithPlacement: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, placement: *const nvmlComputeInstancePlacement_t, computeInstance: *mut nvmlComputeInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlComputeInstanceDestroy: Result<unsafe extern "C" fn(computeInstance: nvmlComputeInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceGetComputeInstances: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, computeInstances: *mut nvmlComputeInstance_t, count: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlGpuInstanceGetComputeInstanceById: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, id: c_uint, computeInstance: *mut nvmlComputeInstance_t) -> nvmlReturn_t, Error>,
    pub nvmlComputeInstanceGetInfo_v2: Result<unsafe extern "C" fn(computeInstance: nvmlComputeInstance_t, info: *mut nvmlComputeInstanceInfo_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceIsMigDeviceHandle: Result<unsafe extern "C" fn(device: nvmlDevice_t, isMigDevice: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetGpuInstanceId: Result<unsafe extern "C" fn(device: nvmlDevice_t, id: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetComputeInstanceId: Result<unsafe extern "C" fn(device: nvmlDevice_t, id: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMaxMigDeviceCount: Result<unsafe extern "C" fn(device: nvmlDevice_t, count: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetMigDeviceHandleByIndex: Result<unsafe extern "C" fn(device: nvmlDevice_t, index: c_uint, migDevice: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlDeviceGetDeviceHandleFromMigDeviceHandle: Result<unsafe extern "C" fn(migDevice: nvmlDevice_t, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>,
    pub nvmlGpmMetricsGet: Result<unsafe extern "C" fn(metricsGet: *mut nvmlGpmMetricsGet_t) -> nvmlReturn_t, Error>,
    pub nvmlGpmSampleFree: Result<unsafe extern "C" fn(gpmSample: nvmlGpmSample_t) -> nvmlReturn_t, Error>,
    pub nvmlGpmSampleAlloc: Result<unsafe extern "C" fn(gpmSample: *mut nvmlGpmSample_t) -> nvmlReturn_t, Error>,
    pub nvmlGpmSampleGet: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpmSample: nvmlGpmSample_t) -> nvmlReturn_t, Error>,
    pub nvmlGpmMigSampleGet: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpuInstanceId: c_uint, gpmSample: nvmlGpmSample_t) -> nvmlReturn_t, Error>,
    pub nvmlGpmQueryDeviceSupport: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpmSupport: *mut nvmlGpmSupport_t) -> nvmlReturn_t, Error>,
    pub nvmlGpmQueryIfStreamingEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, state: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlGpmSetStreamingEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, state: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetNvLinkDeviceLowPowerThreshold: Result<unsafe extern "C" fn(device: nvmlDevice_t, info: *mut nvmlNvLinkPowerThres_t) -> nvmlReturn_t, Error>,
    pub nvmlSystemSetNvlinkBwMode: Result<unsafe extern "C" fn(nvlinkBwMode: c_uint) -> nvmlReturn_t, Error>,
    pub nvmlSystemGetNvlinkBwMode: Result<unsafe extern "C" fn(nvlinkBwMode: *mut c_uint) -> nvmlReturn_t, Error>,
    pub nvmlDeviceSetPowerManagementLimit_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, powerValue: *mut nvmlPowerValue_v2_t) -> nvmlReturn_t, Error>,
}

Fields

__library: Library

nvmlInit_v2: Result<unsafe extern "C" fn() -> nvmlReturn_t, Error>

nvmlInitWithFlags: Result<unsafe extern "C" fn(flags: c_uint) -> nvmlReturn_t, Error>

nvmlShutdown: Result<unsafe extern "C" fn() -> nvmlReturn_t, Error>

nvmlErrorString: Result<unsafe extern "C" fn(result: nvmlReturn_t) -> *const c_char, Error>

nvmlSystemGetDriverVersion: Result<unsafe extern "C" fn(version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlSystemGetNVMLVersion: Result<unsafe extern "C" fn(version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlSystemGetCudaDriverVersion: Result<unsafe extern "C" fn(cudaDriverVersion: *mut c_int) -> nvmlReturn_t, Error>

nvmlSystemGetCudaDriverVersion_v2: Result<unsafe extern "C" fn(cudaDriverVersion: *mut c_int) -> nvmlReturn_t, Error>

nvmlSystemGetProcessName: Result<unsafe extern "C" fn(pid: c_uint, name: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlUnitGetCount: Result<unsafe extern "C" fn(unitCount: *mut c_uint) -> nvmlReturn_t, Error>

nvmlUnitGetHandleByIndex: Result<unsafe extern "C" fn(index: c_uint, unit: *mut nvmlUnit_t) -> nvmlReturn_t, Error>

nvmlUnitGetUnitInfo: Result<unsafe extern "C" fn(unit: nvmlUnit_t, info: *mut nvmlUnitInfo_t) -> nvmlReturn_t, Error>

nvmlUnitGetLedState: Result<unsafe extern "C" fn(unit: nvmlUnit_t, state: *mut nvmlLedState_t) -> nvmlReturn_t, Error>

nvmlUnitGetPsuInfo: Result<unsafe extern "C" fn(unit: nvmlUnit_t, psu: *mut nvmlPSUInfo_t) -> nvmlReturn_t, Error>

nvmlUnitGetTemperature: Result<unsafe extern "C" fn(unit: nvmlUnit_t, type_: c_uint, temp: *mut c_uint) -> nvmlReturn_t, Error>

nvmlUnitGetFanSpeedInfo: Result<unsafe extern "C" fn(unit: nvmlUnit_t, fanSpeeds: *mut nvmlUnitFanSpeeds_t) -> nvmlReturn_t, Error>

nvmlUnitGetDevices: Result<unsafe extern "C" fn(unit: nvmlUnit_t, deviceCount: *mut c_uint, devices: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlSystemGetHicVersion: Result<unsafe extern "C" fn(hwbcCount: *mut c_uint, hwbcEntries: *mut nvmlHwbcEntry_t) -> nvmlReturn_t, Error>

nvmlDeviceGetCount_v2: Result<unsafe extern "C" fn(deviceCount: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetAttributes_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, attributes: *mut nvmlDeviceAttributes_t) -> nvmlReturn_t, Error>

nvmlDeviceGetHandleByIndex_v2: Result<unsafe extern "C" fn(index: c_uint, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetHandleBySerial: Result<unsafe extern "C" fn(serial: *const c_char, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetHandleByUUID: Result<unsafe extern "C" fn(uuid: *const c_char, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetHandleByPciBusId_v2: Result<unsafe extern "C" fn(pciBusId: *const c_char, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetName: Result<unsafe extern "C" fn(device: nvmlDevice_t, name: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetBrand: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: *mut nvmlBrandType_t) -> nvmlReturn_t, Error>

nvmlDeviceGetIndex: Result<unsafe extern "C" fn(device: nvmlDevice_t, index: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetSerial: Result<unsafe extern "C" fn(device: nvmlDevice_t, serial: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetModuleId: Result<unsafe extern "C" fn(device: nvmlDevice_t, moduleId: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMemoryAffinity: Result<unsafe extern "C" fn(device: nvmlDevice_t, nodeSetSize: c_uint, nodeSet: *mut c_ulong, scope: nvmlAffinityScope_t) -> nvmlReturn_t, Error>

nvmlDeviceGetCpuAffinityWithinScope: Result<unsafe extern "C" fn(device: nvmlDevice_t, cpuSetSize: c_uint, cpuSet: *mut c_ulong, scope: nvmlAffinityScope_t) -> nvmlReturn_t, Error>

nvmlDeviceGetCpuAffinity: Result<unsafe extern "C" fn(device: nvmlDevice_t, cpuSetSize: c_uint, cpuSet: *mut c_ulong) -> nvmlReturn_t, Error>

nvmlDeviceSetCpuAffinity: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceClearCpuAffinity: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetTopologyCommonAncestor: Result<unsafe extern "C" fn(device1: nvmlDevice_t, device2: nvmlDevice_t, pathInfo: *mut nvmlGpuTopologyLevel_t) -> nvmlReturn_t, Error>

nvmlDeviceGetTopologyNearestGpus: Result<unsafe extern "C" fn(device: nvmlDevice_t, level: nvmlGpuTopologyLevel_t, count: *mut c_uint, deviceArray: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlSystemGetTopologyGpuSet: Result<unsafe extern "C" fn(cpuNumber: c_uint, count: *mut c_uint, deviceArray: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetP2PStatus: Result<unsafe extern "C" fn(device1: nvmlDevice_t, device2: nvmlDevice_t, p2pIndex: nvmlGpuP2PCapsIndex_t, p2pStatus: *mut nvmlGpuP2PStatus_t) -> nvmlReturn_t, Error>

nvmlDeviceGetUUID: Result<unsafe extern "C" fn(device: nvmlDevice_t, uuid: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetMdevUUID: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, mdevUuid: *mut c_char, size: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMinorNumber: Result<unsafe extern "C" fn(device: nvmlDevice_t, minorNumber: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetBoardPartNumber: Result<unsafe extern "C" fn(device: nvmlDevice_t, partNumber: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetInforomVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, object: nvmlInforomObject_t, version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetInforomImageVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetInforomConfigurationChecksum: Result<unsafe extern "C" fn(device: nvmlDevice_t, checksum: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceValidateInforom: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetDisplayMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, display: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetDisplayActive: Result<unsafe extern "C" fn(device: nvmlDevice_t, isActive: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetPersistenceMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetPciInfo_v3: Result<unsafe extern "C" fn(device: nvmlDevice_t, pci: *mut nvmlPciInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetMaxPcieLinkGeneration: Result<unsafe extern "C" fn(device: nvmlDevice_t, maxLinkGen: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuMaxPcieLinkGeneration: Result<unsafe extern "C" fn(device: nvmlDevice_t, maxLinkGenDevice: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMaxPcieLinkWidth: Result<unsafe extern "C" fn(device: nvmlDevice_t, maxLinkWidth: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetCurrPcieLinkGeneration: Result<unsafe extern "C" fn(device: nvmlDevice_t, currLinkGen: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetCurrPcieLinkWidth: Result<unsafe extern "C" fn(device: nvmlDevice_t, currLinkWidth: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetPcieThroughput: Result<unsafe extern "C" fn(device: nvmlDevice_t, counter: nvmlPcieUtilCounter_t, value: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetPcieReplayCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, value: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetClockInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: nvmlClockType_t, clock: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMaxClockInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: nvmlClockType_t, clock: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetGpcClkVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, offset: *mut c_int) -> nvmlReturn_t, Error>

nvmlDeviceGetApplicationsClock: Result<unsafe extern "C" fn(device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetDefaultApplicationsClock: Result<unsafe extern "C" fn(device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceResetApplicationsClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetClock: Result<unsafe extern "C" fn(device: nvmlDevice_t, clockType: nvmlClockType_t, clockId: nvmlClockId_t, clockMHz: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMaxCustomerBoostClock: Result<unsafe extern "C" fn(device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetSupportedMemoryClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, count: *mut c_uint, clocksMHz: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetSupportedGraphicsClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, memoryClockMHz: c_uint, count: *mut c_uint, clocksMHz: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetAutoBoostedClocksEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, isEnabled: *mut nvmlEnableState_t, defaultIsEnabled: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceSetAutoBoostedClocksEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, enabled: nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceSetDefaultAutoBoostedClocksEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, enabled: nvmlEnableState_t, flags: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetFanSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, speed: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetFanSpeed_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, speed: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetTargetFanSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, targetSpeed: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetDefaultFanSpeed_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMinMaxFanSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, minSpeed: *mut c_uint, maxSpeed: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetFanControlPolicy_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, policy: *mut nvmlFanControlPolicy_t) -> nvmlReturn_t, Error>

nvmlDeviceSetFanControlPolicy: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, policy: nvmlFanControlPolicy_t) -> nvmlReturn_t, Error>

nvmlDeviceGetNumFans: Result<unsafe extern "C" fn(device: nvmlDevice_t, numFans: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetTemperature: Result<unsafe extern "C" fn(device: nvmlDevice_t, sensorType: nvmlTemperatureSensors_t, temp: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetTemperatureThreshold: Result<unsafe extern "C" fn(device: nvmlDevice_t, thresholdType: nvmlTemperatureThresholds_t, temp: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetTemperatureThreshold: Result<unsafe extern "C" fn(device: nvmlDevice_t, thresholdType: nvmlTemperatureThresholds_t, temp: *mut c_int) -> nvmlReturn_t, Error>

nvmlDeviceGetThermalSettings: Result<unsafe extern "C" fn(device: nvmlDevice_t, sensorIndex: c_uint, pThermalSettings: *mut nvmlGpuThermalSettings_t) -> nvmlReturn_t, Error>

nvmlDeviceGetPerformanceState: Result<unsafe extern "C" fn(device: nvmlDevice_t, pState: *mut nvmlPstates_t) -> nvmlReturn_t, Error>

nvmlDeviceGetCurrentClocksEventReasons: Result<unsafe extern "C" fn(device: nvmlDevice_t, clocksEventReasons: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetCurrentClocksThrottleReasons: Result<unsafe extern "C" fn(device: nvmlDevice_t, clocksThrottleReasons: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetSupportedClocksEventReasons: Result<unsafe extern "C" fn(device: nvmlDevice_t, supportedClocksEventReasons: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetSupportedClocksThrottleReasons: Result<unsafe extern "C" fn(device: nvmlDevice_t, supportedClocksThrottleReasons: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetPowerState: Result<unsafe extern "C" fn(device: nvmlDevice_t, pState: *mut nvmlPstates_t) -> nvmlReturn_t, Error>

nvmlDeviceGetDynamicPstatesInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, pDynamicPstatesInfo: *mut nvmlGpuDynamicPstatesInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetMemClkVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, offset: *mut c_int) -> nvmlReturn_t, Error>

nvmlDeviceGetMinMaxClockOfPState: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: nvmlClockType_t, pstate: nvmlPstates_t, minClockMHz: *mut c_uint, maxClockMHz: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetSupportedPerformanceStates: Result<unsafe extern "C" fn(device: nvmlDevice_t, pstates: *mut nvmlPstates_t, size: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetGpcClkMinMaxVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, minOffset: *mut c_int, maxOffset: *mut c_int) -> nvmlReturn_t, Error>

nvmlDeviceGetMemClkMinMaxVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, minOffset: *mut c_int, maxOffset: *mut c_int) -> nvmlReturn_t, Error>

nvmlDeviceGetPowerManagementMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetPowerManagementLimit: Result<unsafe extern "C" fn(device: nvmlDevice_t, limit: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetPowerManagementLimitConstraints: Result<unsafe extern "C" fn(device: nvmlDevice_t, minLimit: *mut c_uint, maxLimit: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetPowerManagementDefaultLimit: Result<unsafe extern "C" fn(device: nvmlDevice_t, defaultLimit: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetPowerUsage: Result<unsafe extern "C" fn(device: nvmlDevice_t, power: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetTotalEnergyConsumption: Result<unsafe extern "C" fn(device: nvmlDevice_t, energy: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetEnforcedPowerLimit: Result<unsafe extern "C" fn(device: nvmlDevice_t, limit: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuOperationMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, current: *mut nvmlGpuOperationMode_t, pending: *mut nvmlGpuOperationMode_t) -> nvmlReturn_t, Error>

nvmlDeviceGetMemoryInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, memory: *mut nvmlMemory_t) -> nvmlReturn_t, Error>

nvmlDeviceGetMemoryInfo_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, memory: *mut nvmlMemory_v2_t) -> nvmlReturn_t, Error>

nvmlDeviceGetComputeMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: *mut nvmlComputeMode_t) -> nvmlReturn_t, Error>

nvmlDeviceGetCudaComputeCapability: Result<unsafe extern "C" fn(device: nvmlDevice_t, major: *mut c_int, minor: *mut c_int) -> nvmlReturn_t, Error>

nvmlDeviceGetEccMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, current: *mut nvmlEnableState_t, pending: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetDefaultEccMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, defaultMode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetBoardId: Result<unsafe extern "C" fn(device: nvmlDevice_t, boardId: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMultiGpuBoard: Result<unsafe extern "C" fn(device: nvmlDevice_t, multiGpuBool: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetTotalEccErrors: Result<unsafe extern "C" fn(device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, eccCounts: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetDetailedEccErrors: Result<unsafe extern "C" fn(device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, eccCounts: *mut nvmlEccErrorCounts_t) -> nvmlReturn_t, Error>

nvmlDeviceGetMemoryErrorCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, locationType: nvmlMemoryLocation_t, count: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetUtilizationRates: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut nvmlUtilization_t) -> nvmlReturn_t, Error>

nvmlDeviceGetEncoderUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetEncoderCapacity: Result<unsafe extern "C" fn(device: nvmlDevice_t, encoderQueryType: nvmlEncoderType_t, encoderCapacity: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetEncoderStats: Result<unsafe extern "C" fn(device: nvmlDevice_t, sessionCount: *mut c_uint, averageFps: *mut c_uint, averageLatency: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetEncoderSessions: Result<unsafe extern "C" fn(device: nvmlDevice_t, sessionCount: *mut c_uint, sessionInfos: *mut nvmlEncoderSessionInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetDecoderUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetJpgUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetOfaUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetFBCStats: Result<unsafe extern "C" fn(device: nvmlDevice_t, fbcStats: *mut nvmlFBCStats_t) -> nvmlReturn_t, Error>

nvmlDeviceGetFBCSessions: Result<unsafe extern "C" fn(device: nvmlDevice_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlFBCSessionInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetDriverModel: Result<unsafe extern "C" fn(device: nvmlDevice_t, current: *mut nvmlDriverModel_t, pending: *mut nvmlDriverModel_t) -> nvmlReturn_t, Error>

nvmlDeviceGetVbiosVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetBridgeChipInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, bridgeHierarchy: *mut nvmlBridgeChipHierarchy_t) -> nvmlReturn_t, Error>

nvmlDeviceGetComputeRunningProcesses_v3: Result<unsafe extern "C" fn(device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetGraphicsRunningProcesses_v3: Result<unsafe extern "C" fn(device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetMPSComputeRunningProcesses_v3: Result<unsafe extern "C" fn(device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetRunningProcessDetailList: Result<unsafe extern "C" fn(device: nvmlDevice_t, plist: *mut nvmlProcessDetailList_t) -> nvmlReturn_t, Error>

nvmlDeviceOnSameBoard: Result<unsafe extern "C" fn(device1: nvmlDevice_t, device2: nvmlDevice_t, onSameBoard: *mut c_int) -> nvmlReturn_t, Error>

nvmlDeviceGetAPIRestriction: Result<unsafe extern "C" fn(device: nvmlDevice_t, apiType: nvmlRestrictedAPI_t, isRestricted: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetSamples: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: nvmlSamplingType_t, lastSeenTimeStamp: c_ulonglong, sampleValType: *mut nvmlValueType_t, sampleCount: *mut c_uint, samples: *mut nvmlSample_t) -> nvmlReturn_t, Error>

nvmlDeviceGetBAR1MemoryInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, bar1Memory: *mut nvmlBAR1Memory_t) -> nvmlReturn_t, Error>

nvmlDeviceGetViolationStatus: Result<unsafe extern "C" fn(device: nvmlDevice_t, perfPolicyType: nvmlPerfPolicyType_t, violTime: *mut nvmlViolationTime_t) -> nvmlReturn_t, Error>

nvmlDeviceGetIrqNum: Result<unsafe extern "C" fn(device: nvmlDevice_t, irqNum: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetNumGpuCores: Result<unsafe extern "C" fn(device: nvmlDevice_t, numCores: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetPowerSource: Result<unsafe extern "C" fn(device: nvmlDevice_t, powerSource: *mut nvmlPowerSource_t) -> nvmlReturn_t, Error>

nvmlDeviceGetMemoryBusWidth: Result<unsafe extern "C" fn(device: nvmlDevice_t, busWidth: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetPcieLinkMaxSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, maxSpeed: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetPcieSpeed: Result<unsafe extern "C" fn(device: nvmlDevice_t, pcieSpeed: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetAdaptiveClockInfoStatus: Result<unsafe extern "C" fn(device: nvmlDevice_t, adaptiveClockStatus: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetBusType: Result<unsafe extern "C" fn(device: nvmlDevice_t, type_: *mut nvmlBusType_t) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuFabricInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpuFabricInfo: *mut nvmlGpuFabricInfo_t) -> nvmlReturn_t, Error>

nvmlSystemGetConfComputeCapabilities: Result<unsafe extern "C" fn(capabilities: *mut nvmlConfComputeSystemCaps_t) -> nvmlReturn_t, Error>

nvmlSystemGetConfComputeState: Result<unsafe extern "C" fn(state: *mut nvmlConfComputeSystemState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetConfComputeMemSizeInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, memInfo: *mut nvmlConfComputeMemSizeInfo_t) -> nvmlReturn_t, Error>

nvmlSystemGetConfComputeGpusReadyState: Result<unsafe extern "C" fn(isAcceptingWork: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetConfComputeProtectedMemoryUsage: Result<unsafe extern "C" fn(device: nvmlDevice_t, memory: *mut nvmlMemory_t) -> nvmlReturn_t, Error>

nvmlDeviceGetConfComputeGpuCertificate: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpuCert: *mut nvmlConfComputeGpuCertificate_t) -> nvmlReturn_t, Error>

nvmlDeviceGetConfComputeGpuAttestationReport: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpuAtstReport: *mut nvmlConfComputeGpuAttestationReport_t) -> nvmlReturn_t, Error>

nvmlDeviceGetAccountingMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetAccountingStats: Result<unsafe extern "C" fn(device: nvmlDevice_t, pid: c_uint, stats: *mut nvmlAccountingStats_t) -> nvmlReturn_t, Error>

nvmlDeviceGetAccountingPids: Result<unsafe extern "C" fn(device: nvmlDevice_t, count: *mut c_uint, pids: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetAccountingBufferSize: Result<unsafe extern "C" fn(device: nvmlDevice_t, bufferSize: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetRetiredPages: Result<unsafe extern "C" fn(device: nvmlDevice_t, cause: nvmlPageRetirementCause_t, pageCount: *mut c_uint, addresses: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetRetiredPages_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, cause: nvmlPageRetirementCause_t, pageCount: *mut c_uint, addresses: *mut c_ulonglong, timestamps: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetRetiredPagesPendingStatus: Result<unsafe extern "C" fn(device: nvmlDevice_t, isPending: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetRemappedRows: Result<unsafe extern "C" fn(device: nvmlDevice_t, corrRows: *mut c_uint, uncRows: *mut c_uint, isPending: *mut c_uint, failureOccurred: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetRowRemapperHistogram: Result<unsafe extern "C" fn(device: nvmlDevice_t, values: *mut nvmlRowRemapperHistogramValues_t) -> nvmlReturn_t, Error>

nvmlDeviceGetArchitecture: Result<unsafe extern "C" fn(device: nvmlDevice_t, arch: *mut nvmlDeviceArchitecture_t) -> nvmlReturn_t, Error>

nvmlUnitSetLedState: Result<unsafe extern "C" fn(unit: nvmlUnit_t, color: nvmlLedColor_t) -> nvmlReturn_t, Error>

nvmlDeviceSetPersistenceMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceSetComputeMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: nvmlComputeMode_t) -> nvmlReturn_t, Error>

nvmlDeviceSetEccMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, ecc: nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceClearEccErrorCounts: Result<unsafe extern "C" fn(device: nvmlDevice_t, counterType: nvmlEccCounterType_t) -> nvmlReturn_t, Error>

nvmlDeviceSetDriverModel: Result<unsafe extern "C" fn(device: nvmlDevice_t, driverModel: nvmlDriverModel_t, flags: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetGpuLockedClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, minGpuClockMHz: c_uint, maxGpuClockMHz: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceResetGpuLockedClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceSetMemoryLockedClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, minMemClockMHz: c_uint, maxMemClockMHz: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceResetMemoryLockedClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceSetApplicationsClocks: Result<unsafe extern "C" fn(device: nvmlDevice_t, memClockMHz: c_uint, graphicsClockMHz: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetClkMonStatus: Result<unsafe extern "C" fn(device: nvmlDevice_t, status: *mut nvmlClkMonStatus_t) -> nvmlReturn_t, Error>

nvmlDeviceSetPowerManagementLimit: Result<unsafe extern "C" fn(device: nvmlDevice_t, limit: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetGpuOperationMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: nvmlGpuOperationMode_t) -> nvmlReturn_t, Error>

nvmlDeviceSetAPIRestriction: Result<unsafe extern "C" fn(device: nvmlDevice_t, apiType: nvmlRestrictedAPI_t, isRestricted: nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceSetFanSpeed_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, fan: c_uint, speed: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetGpcClkVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, offset: c_int) -> nvmlReturn_t, Error>

nvmlDeviceSetMemClkVfOffset: Result<unsafe extern "C" fn(device: nvmlDevice_t, offset: c_int) -> nvmlReturn_t, Error>

nvmlDeviceSetConfComputeUnprotectedMemSize: Result<unsafe extern "C" fn(device: nvmlDevice_t, sizeKiB: c_ulonglong) -> nvmlReturn_t, Error>

nvmlSystemSetConfComputeGpusReadyState: Result<unsafe extern "C" fn(isAcceptingWork: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetAccountingMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceClearAccountingPids: Result<unsafe extern "C" fn(device: nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetNvLinkState: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, isActive: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetNvLinkVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, version: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetNvLinkCapability: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, capability: nvmlNvLinkCapability_t, capResult: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetNvLinkRemotePciInfo_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, pci: *mut nvmlPciInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetNvLinkErrorCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: nvmlNvLinkErrorCounter_t, counterValue: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceResetNvLinkErrorCounters: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetNvLinkUtilizationControl: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint, control: *mut nvmlNvLinkUtilizationControl_t, reset: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetNvLinkUtilizationControl: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint, control: *mut nvmlNvLinkUtilizationControl_t) -> nvmlReturn_t, Error>

nvmlDeviceGetNvLinkUtilizationCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint, rxcounter: *mut c_ulonglong, txcounter: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceFreezeNvLinkUtilizationCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint, freeze: nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceResetNvLinkUtilizationCounter: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, counter: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetNvLinkRemoteDeviceType: Result<unsafe extern "C" fn(device: nvmlDevice_t, link: c_uint, pNvLinkDeviceType: *mut nvmlIntNvLinkDeviceType_t) -> nvmlReturn_t, Error>

nvmlEventSetCreate: Result<unsafe extern "C" fn(set: *mut nvmlEventSet_t) -> nvmlReturn_t, Error>

nvmlDeviceRegisterEvents: Result<unsafe extern "C" fn(device: nvmlDevice_t, eventTypes: c_ulonglong, set: nvmlEventSet_t) -> nvmlReturn_t, Error>

nvmlDeviceGetSupportedEventTypes: Result<unsafe extern "C" fn(device: nvmlDevice_t, eventTypes: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlEventSetWait_v2: Result<unsafe extern "C" fn(set: nvmlEventSet_t, data: *mut nvmlEventData_t, timeoutms: c_uint) -> nvmlReturn_t, Error>

nvmlEventSetFree: Result<unsafe extern "C" fn(set: nvmlEventSet_t) -> nvmlReturn_t, Error>

nvmlDeviceModifyDrainState: Result<unsafe extern "C" fn(pciInfo: *mut nvmlPciInfo_t, newState: nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceQueryDrainState: Result<unsafe extern "C" fn(pciInfo: *mut nvmlPciInfo_t, currentState: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlDeviceRemoveGpu_v2: Result<unsafe extern "C" fn(pciInfo: *mut nvmlPciInfo_t, gpuState: nvmlDetachGpuState_t, linkState: nvmlPcieLinkState_t) -> nvmlReturn_t, Error>

nvmlDeviceDiscoverGpus: Result<unsafe extern "C" fn(pciInfo: *mut nvmlPciInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetFieldValues: Result<unsafe extern "C" fn(device: nvmlDevice_t, valuesCount: c_int, values: *mut nvmlFieldValue_t) -> nvmlReturn_t, Error>

nvmlDeviceClearFieldValues: Result<unsafe extern "C" fn(device: nvmlDevice_t, valuesCount: c_int, values: *mut nvmlFieldValue_t) -> nvmlReturn_t, Error>

nvmlDeviceGetVirtualizationMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, pVirtualMode: *mut nvmlGpuVirtualizationMode_t) -> nvmlReturn_t, Error>

nvmlDeviceGetHostVgpuMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, pHostVgpuMode: *mut nvmlHostVgpuMode_t) -> nvmlReturn_t, Error>

nvmlDeviceSetVirtualizationMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, virtualMode: nvmlGpuVirtualizationMode_t) -> nvmlReturn_t, Error>

nvmlDeviceGetGridLicensableFeatures_v4: Result<unsafe extern "C" fn(device: nvmlDevice_t, pGridLicensableFeatures: *mut nvmlGridLicensableFeatures_t) -> nvmlReturn_t, Error>

nvmlDeviceGetProcessUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, utilization: *mut nvmlProcessUtilizationSample_t, processSamplesCount: *mut c_uint, lastSeenTimeStamp: c_ulonglong) -> nvmlReturn_t, Error>

nvmlDeviceGetGspFirmwareVersion: Result<unsafe extern "C" fn(device: nvmlDevice_t, version: *mut c_char) -> nvmlReturn_t, Error>

nvmlDeviceGetGspFirmwareMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, isEnabled: *mut c_uint, defaultMode: *mut c_uint) -> nvmlReturn_t, Error>

nvmlGetVgpuDriverCapabilities: Result<unsafe extern "C" fn(capability: nvmlVgpuDriverCapability_t, capResult: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetVgpuCapabilities: Result<unsafe extern "C" fn(device: nvmlDevice_t, capability: nvmlDeviceVgpuCapability_t, capResult: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetSupportedVgpus: Result<unsafe extern "C" fn(device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuTypeIds: *mut nvmlVgpuTypeId_t) -> nvmlReturn_t, Error>

nvmlDeviceGetCreatableVgpus: Result<unsafe extern "C" fn(device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuTypeIds: *mut nvmlVgpuTypeId_t) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetClass: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeClass: *mut c_char, size: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetName: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeName: *mut c_char, size: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetGpuInstanceProfileId: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, gpuInstanceProfileId: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetDeviceID: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, deviceID: *mut c_ulonglong, subsystemID: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetFramebufferSize: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, fbSize: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetNumDisplayHeads: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, numDisplayHeads: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetResolution: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, displayIndex: c_uint, xdim: *mut c_uint, ydim: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetLicense: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeLicenseString: *mut c_char, size: c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetFrameRateLimit: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, frameRateLimit: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetMaxInstances: Result<unsafe extern "C" fn(device: nvmlDevice_t, vgpuTypeId: nvmlVgpuTypeId_t, vgpuInstanceCount: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetMaxInstancesPerVm: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, vgpuInstanceCountPerVm: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetActiveVgpus: Result<unsafe extern "C" fn(device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuInstances: *mut nvmlVgpuInstance_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetVmID: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, vmId: *mut c_char, size: c_uint, vmIdType: *mut nvmlVgpuVmIdType_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetUUID: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, uuid: *mut c_char, size: c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetVmDriverVersion: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, version: *mut c_char, length: c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetFbUsage: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, fbUsage: *mut c_ulonglong) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetLicenseStatus: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, licensed: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetType: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, vgpuTypeId: *mut nvmlVgpuTypeId_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetFrameRateLimit: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, frameRateLimit: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetEccMode: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, eccMode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetEncoderCapacity: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, encoderCapacity: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceSetEncoderCapacity: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, encoderCapacity: c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetEncoderStats: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, averageFps: *mut c_uint, averageLatency: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetEncoderSessions: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlEncoderSessionInfo_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetFBCStats: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, fbcStats: *mut nvmlFBCStats_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetFBCSessions: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlFBCSessionInfo_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetGpuInstanceId: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, gpuInstanceId: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetGpuPciId: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, vgpuPciId: *mut c_char, length: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuTypeGetCapabilities: Result<unsafe extern "C" fn(vgpuTypeId: nvmlVgpuTypeId_t, capability: nvmlVgpuCapability_t, capResult: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetMetadata: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, vgpuMetadata: *mut nvmlVgpuMetadata_t, bufferSize: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetVgpuMetadata: Result<unsafe extern "C" fn(device: nvmlDevice_t, pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, bufferSize: *mut c_uint) -> nvmlReturn_t, Error>

nvmlGetVgpuCompatibility: Result<unsafe extern "C" fn(vgpuMetadata: *mut nvmlVgpuMetadata_t, pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, compatibilityInfo: *mut nvmlVgpuPgpuCompatibility_t) -> nvmlReturn_t, Error>

nvmlDeviceGetPgpuMetadataString: Result<unsafe extern "C" fn(device: nvmlDevice_t, pgpuMetadata: *mut c_char, bufferSize: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetVgpuSchedulerLog: Result<unsafe extern "C" fn(device: nvmlDevice_t, pSchedulerLog: *mut nvmlVgpuSchedulerLog_t) -> nvmlReturn_t, Error>

nvmlDeviceGetVgpuSchedulerState: Result<unsafe extern "C" fn(device: nvmlDevice_t, pSchedulerState: *mut nvmlVgpuSchedulerGetState_t) -> nvmlReturn_t, Error>

nvmlDeviceGetVgpuSchedulerCapabilities: Result<unsafe extern "C" fn(device: nvmlDevice_t, pCapabilities: *mut nvmlVgpuSchedulerCapabilities_t) -> nvmlReturn_t, Error>

nvmlDeviceSetVgpuSchedulerState: Result<unsafe extern "C" fn(device: nvmlDevice_t, pSchedulerState: *mut nvmlVgpuSchedulerSetState_t) -> nvmlReturn_t, Error>

nvmlGetVgpuVersion: Result<unsafe extern "C" fn(supported: *mut nvmlVgpuVersion_t, current: *mut nvmlVgpuVersion_t) -> nvmlReturn_t, Error>

nvmlSetVgpuVersion: Result<unsafe extern "C" fn(vgpuVersion: *mut nvmlVgpuVersion_t) -> nvmlReturn_t, Error>

nvmlDeviceGetVgpuUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, lastSeenTimeStamp: c_ulonglong, sampleValType: *mut nvmlValueType_t, vgpuInstanceSamplesCount: *mut c_uint, utilizationSamples: *mut nvmlVgpuInstanceUtilizationSample_t) -> nvmlReturn_t, Error>

nvmlDeviceGetVgpuProcessUtilization: Result<unsafe extern "C" fn(device: nvmlDevice_t, lastSeenTimeStamp: c_ulonglong, vgpuProcessSamplesCount: *mut c_uint, utilizationSamples: *mut nvmlVgpuProcessUtilizationSample_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetAccountingMode: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, mode: *mut nvmlEnableState_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetAccountingPids: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, count: *mut c_uint, pids: *mut c_uint) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetAccountingStats: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, pid: c_uint, stats: *mut nvmlAccountingStats_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceClearAccountingPids: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t) -> nvmlReturn_t, Error>

nvmlVgpuInstanceGetLicenseInfo_v2: Result<unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t, licenseInfo: *mut nvmlVgpuLicenseInfo_t) -> nvmlReturn_t, Error>

nvmlGetExcludedDeviceCount: Result<unsafe extern "C" fn(deviceCount: *mut c_uint) -> nvmlReturn_t, Error>

nvmlGetExcludedDeviceInfoByIndex: Result<unsafe extern "C" fn(index: c_uint, info: *mut nvmlExcludedDeviceInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceSetMigMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, mode: c_uint, activationStatus: *mut nvmlReturn_t) -> nvmlReturn_t, Error>

nvmlDeviceGetMigMode: Result<unsafe extern "C" fn(device: nvmlDevice_t, currentMode: *mut c_uint, pendingMode: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuInstanceProfileInfo: Result<unsafe extern "C" fn(device: nvmlDevice_t, profile: c_uint, info: *mut nvmlGpuInstanceProfileInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuInstanceProfileInfoV: Result<unsafe extern "C" fn(device: nvmlDevice_t, profile: c_uint, info: *mut nvmlGpuInstanceProfileInfo_v2_t) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuInstancePossiblePlacements_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, placements: *mut nvmlGpuInstancePlacement_t, count: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuInstanceRemainingCapacity: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, count: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceCreateGpuInstance: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, gpuInstance: *mut nvmlGpuInstance_t) -> nvmlReturn_t, Error>

nvmlDeviceCreateGpuInstanceWithPlacement: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, placement: *const nvmlGpuInstancePlacement_t, gpuInstance: *mut nvmlGpuInstance_t) -> nvmlReturn_t, Error>

nvmlGpuInstanceDestroy: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuInstances: Result<unsafe extern "C" fn(device: nvmlDevice_t, profileId: c_uint, gpuInstances: *mut nvmlGpuInstance_t, count: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuInstanceById: Result<unsafe extern "C" fn(device: nvmlDevice_t, id: c_uint, gpuInstance: *mut nvmlGpuInstance_t) -> nvmlReturn_t, Error>

nvmlGpuInstanceGetInfo: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, info: *mut nvmlGpuInstanceInfo_t) -> nvmlReturn_t, Error>

nvmlGpuInstanceGetComputeInstanceProfileInfo: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profile: c_uint, engProfile: c_uint, info: *mut nvmlComputeInstanceProfileInfo_t) -> nvmlReturn_t, Error>

nvmlGpuInstanceGetComputeInstanceProfileInfoV: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profile: c_uint, engProfile: c_uint, info: *mut nvmlComputeInstanceProfileInfo_v2_t) -> nvmlReturn_t, Error>

nvmlGpuInstanceGetComputeInstanceRemainingCapacity: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, count: *mut c_uint) -> nvmlReturn_t, Error>

nvmlGpuInstanceGetComputeInstancePossiblePlacements: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, placements: *mut nvmlComputeInstancePlacement_t, count: *mut c_uint) -> nvmlReturn_t, Error>

nvmlGpuInstanceCreateComputeInstance: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, computeInstance: *mut nvmlComputeInstance_t) -> nvmlReturn_t, Error>

nvmlGpuInstanceCreateComputeInstanceWithPlacement: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, placement: *const nvmlComputeInstancePlacement_t, computeInstance: *mut nvmlComputeInstance_t) -> nvmlReturn_t, Error>

nvmlComputeInstanceDestroy: Result<unsafe extern "C" fn(computeInstance: nvmlComputeInstance_t) -> nvmlReturn_t, Error>

nvmlGpuInstanceGetComputeInstances: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, profileId: c_uint, computeInstances: *mut nvmlComputeInstance_t, count: *mut c_uint) -> nvmlReturn_t, Error>

nvmlGpuInstanceGetComputeInstanceById: Result<unsafe extern "C" fn(gpuInstance: nvmlGpuInstance_t, id: c_uint, computeInstance: *mut nvmlComputeInstance_t) -> nvmlReturn_t, Error>

nvmlComputeInstanceGetInfo_v2: Result<unsafe extern "C" fn(computeInstance: nvmlComputeInstance_t, info: *mut nvmlComputeInstanceInfo_t) -> nvmlReturn_t, Error>

nvmlDeviceIsMigDeviceHandle: Result<unsafe extern "C" fn(device: nvmlDevice_t, isMigDevice: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetGpuInstanceId: Result<unsafe extern "C" fn(device: nvmlDevice_t, id: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetComputeInstanceId: Result<unsafe extern "C" fn(device: nvmlDevice_t, id: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMaxMigDeviceCount: Result<unsafe extern "C" fn(device: nvmlDevice_t, count: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceGetMigDeviceHandleByIndex: Result<unsafe extern "C" fn(device: nvmlDevice_t, index: c_uint, migDevice: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlDeviceGetDeviceHandleFromMigDeviceHandle: Result<unsafe extern "C" fn(migDevice: nvmlDevice_t, device: *mut nvmlDevice_t) -> nvmlReturn_t, Error>

nvmlGpmMetricsGet: Result<unsafe extern "C" fn(metricsGet: *mut nvmlGpmMetricsGet_t) -> nvmlReturn_t, Error>

nvmlGpmSampleFree: Result<unsafe extern "C" fn(gpmSample: nvmlGpmSample_t) -> nvmlReturn_t, Error>

nvmlGpmSampleAlloc: Result<unsafe extern "C" fn(gpmSample: *mut nvmlGpmSample_t) -> nvmlReturn_t, Error>

nvmlGpmSampleGet: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpmSample: nvmlGpmSample_t) -> nvmlReturn_t, Error>

nvmlGpmMigSampleGet: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpuInstanceId: c_uint, gpmSample: nvmlGpmSample_t) -> nvmlReturn_t, Error>

nvmlGpmQueryDeviceSupport: Result<unsafe extern "C" fn(device: nvmlDevice_t, gpmSupport: *mut nvmlGpmSupport_t) -> nvmlReturn_t, Error>

nvmlGpmQueryIfStreamingEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, state: *mut c_uint) -> nvmlReturn_t, Error>

nvmlGpmSetStreamingEnabled: Result<unsafe extern "C" fn(device: nvmlDevice_t, state: c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetNvLinkDeviceLowPowerThreshold: Result<unsafe extern "C" fn(device: nvmlDevice_t, info: *mut nvmlNvLinkPowerThres_t) -> nvmlReturn_t, Error>

nvmlSystemSetNvlinkBwMode: Result<unsafe extern "C" fn(nvlinkBwMode: c_uint) -> nvmlReturn_t, Error>

nvmlSystemGetNvlinkBwMode: Result<unsafe extern "C" fn(nvlinkBwMode: *mut c_uint) -> nvmlReturn_t, Error>

nvmlDeviceSetPowerManagementLimit_v2: Result<unsafe extern "C" fn(device: nvmlDevice_t, powerValue: *mut nvmlPowerValue_v2_t) -> nvmlReturn_t, Error>

Implementations

impl NvmlLib

pub unsafe fn new<P>(path: P) -> Result<Self, Error>

where P: AsRef<OsStr>,

pub unsafe fn from_library<L>(library: L) -> Result<Self, Error>

where L: Into<Library>,

pub unsafe fn nvmlInit_v2(&self) -> nvmlReturn_t

pub unsafe fn nvmlInitWithFlags(&self, flags: c_uint) -> nvmlReturn_t

pub unsafe fn nvmlShutdown(&self) -> nvmlReturn_t

pub unsafe fn nvmlErrorString(&self, result: nvmlReturn_t) -> *const c_char

pub unsafe fn nvmlSystemGetDriverVersion( &self, version: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetNVMLVersion( &self, version: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetCudaDriverVersion( &self, cudaDriverVersion: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetCudaDriverVersion_v2( &self, cudaDriverVersion: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetProcessName( &self, pid: c_uint, name: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlUnitGetCount(&self, unitCount: *mut c_uint) -> nvmlReturn_t

pub unsafe fn nvmlUnitGetHandleByIndex( &self, index: c_uint, unit: *mut nvmlUnit_t ) -> nvmlReturn_t

pub unsafe fn nvmlUnitGetUnitInfo( &self, unit: nvmlUnit_t, info: *mut nvmlUnitInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlUnitGetLedState( &self, unit: nvmlUnit_t, state: *mut nvmlLedState_t ) -> nvmlReturn_t

pub unsafe fn nvmlUnitGetPsuInfo( &self, unit: nvmlUnit_t, psu: *mut nvmlPSUInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlUnitGetTemperature( &self, unit: nvmlUnit_t, type_: c_uint, temp: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlUnitGetFanSpeedInfo( &self, unit: nvmlUnit_t, fanSpeeds: *mut nvmlUnitFanSpeeds_t ) -> nvmlReturn_t

pub unsafe fn nvmlUnitGetDevices( &self, unit: nvmlUnit_t, deviceCount: *mut c_uint, devices: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetHicVersion( &self, hwbcCount: *mut c_uint, hwbcEntries: *mut nvmlHwbcEntry_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCount_v2( &self, deviceCount: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetAttributes_v2( &self, device: nvmlDevice_t, attributes: *mut nvmlDeviceAttributes_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetHandleByIndex_v2( &self, index: c_uint, device: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetHandleBySerial( &self, serial: *const c_char, device: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetHandleByUUID( &self, uuid: *const c_char, device: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetHandleByPciBusId_v2( &self, pciBusId: *const c_char, device: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetName( &self, device: nvmlDevice_t, name: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetBrand( &self, device: nvmlDevice_t, type_: *mut nvmlBrandType_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetIndex( &self, device: nvmlDevice_t, index: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSerial( &self, device: nvmlDevice_t, serial: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetModuleId( &self, device: nvmlDevice_t, moduleId: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMemoryAffinity( &self, device: nvmlDevice_t, nodeSetSize: c_uint, nodeSet: *mut c_ulong, scope: nvmlAffinityScope_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCpuAffinityWithinScope( &self, device: nvmlDevice_t, cpuSetSize: c_uint, cpuSet: *mut c_ulong, scope: nvmlAffinityScope_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCpuAffinity( &self, device: nvmlDevice_t, cpuSetSize: c_uint, cpuSet: *mut c_ulong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetCpuAffinity( &self, device: nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceClearCpuAffinity( &self, device: nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetTopologyCommonAncestor( &self, device1: nvmlDevice_t, device2: nvmlDevice_t, pathInfo: *mut nvmlGpuTopologyLevel_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetTopologyNearestGpus( &self, device: nvmlDevice_t, level: nvmlGpuTopologyLevel_t, count: *mut c_uint, deviceArray: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetTopologyGpuSet( &self, cpuNumber: c_uint, count: *mut c_uint, deviceArray: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetP2PStatus( &self, device1: nvmlDevice_t, device2: nvmlDevice_t, p2pIndex: nvmlGpuP2PCapsIndex_t, p2pStatus: *mut nvmlGpuP2PStatus_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetUUID( &self, device: nvmlDevice_t, uuid: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetMdevUUID( &self, vgpuInstance: nvmlVgpuInstance_t, mdevUuid: *mut c_char, size: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMinorNumber( &self, device: nvmlDevice_t, minorNumber: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetBoardPartNumber( &self, device: nvmlDevice_t, partNumber: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetInforomVersion( &self, device: nvmlDevice_t, object: nvmlInforomObject_t, version: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetInforomImageVersion( &self, device: nvmlDevice_t, version: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetInforomConfigurationChecksum( &self, device: nvmlDevice_t, checksum: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceValidateInforom( &self, device: nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDisplayMode( &self, device: nvmlDevice_t, display: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDisplayActive( &self, device: nvmlDevice_t, isActive: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPersistenceMode( &self, device: nvmlDevice_t, mode: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPciInfo_v3( &self, device: nvmlDevice_t, pci: *mut nvmlPciInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMaxPcieLinkGeneration( &self, device: nvmlDevice_t, maxLinkGen: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuMaxPcieLinkGeneration( &self, device: nvmlDevice_t, maxLinkGenDevice: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMaxPcieLinkWidth( &self, device: nvmlDevice_t, maxLinkWidth: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCurrPcieLinkGeneration( &self, device: nvmlDevice_t, currLinkGen: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCurrPcieLinkWidth( &self, device: nvmlDevice_t, currLinkWidth: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPcieThroughput( &self, device: nvmlDevice_t, counter: nvmlPcieUtilCounter_t, value: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPcieReplayCounter( &self, device: nvmlDevice_t, value: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetClockInfo( &self, device: nvmlDevice_t, type_: nvmlClockType_t, clock: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMaxClockInfo( &self, device: nvmlDevice_t, type_: nvmlClockType_t, clock: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpcClkVfOffset( &self, device: nvmlDevice_t, offset: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetApplicationsClock( &self, device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDefaultApplicationsClock( &self, device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceResetApplicationsClocks( &self, device: nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetClock( &self, device: nvmlDevice_t, clockType: nvmlClockType_t, clockId: nvmlClockId_t, clockMHz: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMaxCustomerBoostClock( &self, device: nvmlDevice_t, clockType: nvmlClockType_t, clockMHz: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSupportedMemoryClocks( &self, device: nvmlDevice_t, count: *mut c_uint, clocksMHz: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSupportedGraphicsClocks( &self, device: nvmlDevice_t, memoryClockMHz: c_uint, count: *mut c_uint, clocksMHz: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetAutoBoostedClocksEnabled( &self, device: nvmlDevice_t, isEnabled: *mut nvmlEnableState_t, defaultIsEnabled: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetAutoBoostedClocksEnabled( &self, device: nvmlDevice_t, enabled: nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetDefaultAutoBoostedClocksEnabled( &self, device: nvmlDevice_t, enabled: nvmlEnableState_t, flags: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetFanSpeed( &self, device: nvmlDevice_t, speed: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetFanSpeed_v2( &self, device: nvmlDevice_t, fan: c_uint, speed: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetTargetFanSpeed( &self, device: nvmlDevice_t, fan: c_uint, targetSpeed: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetDefaultFanSpeed_v2( &self, device: nvmlDevice_t, fan: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMinMaxFanSpeed( &self, device: nvmlDevice_t, minSpeed: *mut c_uint, maxSpeed: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetFanControlPolicy_v2( &self, device: nvmlDevice_t, fan: c_uint, policy: *mut nvmlFanControlPolicy_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetFanControlPolicy( &self, device: nvmlDevice_t, fan: c_uint, policy: nvmlFanControlPolicy_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNumFans( &self, device: nvmlDevice_t, numFans: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetTemperature( &self, device: nvmlDevice_t, sensorType: nvmlTemperatureSensors_t, temp: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetTemperatureThreshold( &self, device: nvmlDevice_t, thresholdType: nvmlTemperatureThresholds_t, temp: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetTemperatureThreshold( &self, device: nvmlDevice_t, thresholdType: nvmlTemperatureThresholds_t, temp: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetThermalSettings( &self, device: nvmlDevice_t, sensorIndex: c_uint, pThermalSettings: *mut nvmlGpuThermalSettings_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPerformanceState( &self, device: nvmlDevice_t, pState: *mut nvmlPstates_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCurrentClocksEventReasons( &self, device: nvmlDevice_t, clocksEventReasons: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCurrentClocksThrottleReasons( &self, device: nvmlDevice_t, clocksThrottleReasons: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSupportedClocksEventReasons( &self, device: nvmlDevice_t, supportedClocksEventReasons: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSupportedClocksThrottleReasons( &self, device: nvmlDevice_t, supportedClocksThrottleReasons: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPowerState( &self, device: nvmlDevice_t, pState: *mut nvmlPstates_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDynamicPstatesInfo( &self, device: nvmlDevice_t, pDynamicPstatesInfo: *mut nvmlGpuDynamicPstatesInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMemClkVfOffset( &self, device: nvmlDevice_t, offset: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMinMaxClockOfPState( &self, device: nvmlDevice_t, type_: nvmlClockType_t, pstate: nvmlPstates_t, minClockMHz: *mut c_uint, maxClockMHz: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSupportedPerformanceStates( &self, device: nvmlDevice_t, pstates: *mut nvmlPstates_t, size: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpcClkMinMaxVfOffset( &self, device: nvmlDevice_t, minOffset: *mut c_int, maxOffset: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMemClkMinMaxVfOffset( &self, device: nvmlDevice_t, minOffset: *mut c_int, maxOffset: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPowerManagementMode( &self, device: nvmlDevice_t, mode: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPowerManagementLimit( &self, device: nvmlDevice_t, limit: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPowerManagementLimitConstraints( &self, device: nvmlDevice_t, minLimit: *mut c_uint, maxLimit: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPowerManagementDefaultLimit( &self, device: nvmlDevice_t, defaultLimit: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPowerUsage( &self, device: nvmlDevice_t, power: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetTotalEnergyConsumption( &self, device: nvmlDevice_t, energy: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetEnforcedPowerLimit( &self, device: nvmlDevice_t, limit: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuOperationMode( &self, device: nvmlDevice_t, current: *mut nvmlGpuOperationMode_t, pending: *mut nvmlGpuOperationMode_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMemoryInfo( &self, device: nvmlDevice_t, memory: *mut nvmlMemory_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMemoryInfo_v2( &self, device: nvmlDevice_t, memory: *mut nvmlMemory_v2_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetComputeMode( &self, device: nvmlDevice_t, mode: *mut nvmlComputeMode_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCudaComputeCapability( &self, device: nvmlDevice_t, major: *mut c_int, minor: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetEccMode( &self, device: nvmlDevice_t, current: *mut nvmlEnableState_t, pending: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDefaultEccMode( &self, device: nvmlDevice_t, defaultMode: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetBoardId( &self, device: nvmlDevice_t, boardId: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMultiGpuBoard( &self, device: nvmlDevice_t, multiGpuBool: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetTotalEccErrors( &self, device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, eccCounts: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDetailedEccErrors( &self, device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, eccCounts: *mut nvmlEccErrorCounts_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMemoryErrorCounter( &self, device: nvmlDevice_t, errorType: nvmlMemoryErrorType_t, counterType: nvmlEccCounterType_t, locationType: nvmlMemoryLocation_t, count: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetUtilizationRates( &self, device: nvmlDevice_t, utilization: *mut nvmlUtilization_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetEncoderUtilization( &self, device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetEncoderCapacity( &self, device: nvmlDevice_t, encoderQueryType: nvmlEncoderType_t, encoderCapacity: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetEncoderStats( &self, device: nvmlDevice_t, sessionCount: *mut c_uint, averageFps: *mut c_uint, averageLatency: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetEncoderSessions( &self, device: nvmlDevice_t, sessionCount: *mut c_uint, sessionInfos: *mut nvmlEncoderSessionInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDecoderUtilization( &self, device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetJpgUtilization( &self, device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetOfaUtilization( &self, device: nvmlDevice_t, utilization: *mut c_uint, samplingPeriodUs: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetFBCStats( &self, device: nvmlDevice_t, fbcStats: *mut nvmlFBCStats_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetFBCSessions( &self, device: nvmlDevice_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlFBCSessionInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDriverModel( &self, device: nvmlDevice_t, current: *mut nvmlDriverModel_t, pending: *mut nvmlDriverModel_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVbiosVersion( &self, device: nvmlDevice_t, version: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetBridgeChipInfo( &self, device: nvmlDevice_t, bridgeHierarchy: *mut nvmlBridgeChipHierarchy_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetComputeRunningProcesses_v3( &self, device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGraphicsRunningProcesses_v3( &self, device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMPSComputeRunningProcesses_v3( &self, device: nvmlDevice_t, infoCount: *mut c_uint, infos: *mut nvmlProcessInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetRunningProcessDetailList( &self, device: nvmlDevice_t, plist: *mut nvmlProcessDetailList_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceOnSameBoard( &self, device1: nvmlDevice_t, device2: nvmlDevice_t, onSameBoard: *mut c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetAPIRestriction( &self, device: nvmlDevice_t, apiType: nvmlRestrictedAPI_t, isRestricted: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSamples( &self, device: nvmlDevice_t, type_: nvmlSamplingType_t, lastSeenTimeStamp: c_ulonglong, sampleValType: *mut nvmlValueType_t, sampleCount: *mut c_uint, samples: *mut nvmlSample_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetBAR1MemoryInfo( &self, device: nvmlDevice_t, bar1Memory: *mut nvmlBAR1Memory_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetViolationStatus( &self, device: nvmlDevice_t, perfPolicyType: nvmlPerfPolicyType_t, violTime: *mut nvmlViolationTime_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetIrqNum( &self, device: nvmlDevice_t, irqNum: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNumGpuCores( &self, device: nvmlDevice_t, numCores: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPowerSource( &self, device: nvmlDevice_t, powerSource: *mut nvmlPowerSource_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMemoryBusWidth( &self, device: nvmlDevice_t, busWidth: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPcieLinkMaxSpeed( &self, device: nvmlDevice_t, maxSpeed: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPcieSpeed( &self, device: nvmlDevice_t, pcieSpeed: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetAdaptiveClockInfoStatus( &self, device: nvmlDevice_t, adaptiveClockStatus: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetBusType( &self, device: nvmlDevice_t, type_: *mut nvmlBusType_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuFabricInfo( &self, device: nvmlDevice_t, gpuFabricInfo: *mut nvmlGpuFabricInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetConfComputeCapabilities( &self, capabilities: *mut nvmlConfComputeSystemCaps_t ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetConfComputeState( &self, state: *mut nvmlConfComputeSystemState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetConfComputeMemSizeInfo( &self, device: nvmlDevice_t, memInfo: *mut nvmlConfComputeMemSizeInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetConfComputeGpusReadyState( &self, isAcceptingWork: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetConfComputeProtectedMemoryUsage( &self, device: nvmlDevice_t, memory: *mut nvmlMemory_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetConfComputeGpuCertificate( &self, device: nvmlDevice_t, gpuCert: *mut nvmlConfComputeGpuCertificate_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetConfComputeGpuAttestationReport( &self, device: nvmlDevice_t, gpuAtstReport: *mut nvmlConfComputeGpuAttestationReport_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetAccountingMode( &self, device: nvmlDevice_t, mode: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetAccountingStats( &self, device: nvmlDevice_t, pid: c_uint, stats: *mut nvmlAccountingStats_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetAccountingPids( &self, device: nvmlDevice_t, count: *mut c_uint, pids: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetAccountingBufferSize( &self, device: nvmlDevice_t, bufferSize: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetRetiredPages( &self, device: nvmlDevice_t, cause: nvmlPageRetirementCause_t, pageCount: *mut c_uint, addresses: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetRetiredPages_v2( &self, device: nvmlDevice_t, cause: nvmlPageRetirementCause_t, pageCount: *mut c_uint, addresses: *mut c_ulonglong, timestamps: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetRetiredPagesPendingStatus( &self, device: nvmlDevice_t, isPending: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetRemappedRows( &self, device: nvmlDevice_t, corrRows: *mut c_uint, uncRows: *mut c_uint, isPending: *mut c_uint, failureOccurred: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetRowRemapperHistogram( &self, device: nvmlDevice_t, values: *mut nvmlRowRemapperHistogramValues_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetArchitecture( &self, device: nvmlDevice_t, arch: *mut nvmlDeviceArchitecture_t ) -> nvmlReturn_t

pub unsafe fn nvmlUnitSetLedState( &self, unit: nvmlUnit_t, color: nvmlLedColor_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetPersistenceMode( &self, device: nvmlDevice_t, mode: nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetComputeMode( &self, device: nvmlDevice_t, mode: nvmlComputeMode_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetEccMode( &self, device: nvmlDevice_t, ecc: nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceClearEccErrorCounts( &self, device: nvmlDevice_t, counterType: nvmlEccCounterType_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetDriverModel( &self, device: nvmlDevice_t, driverModel: nvmlDriverModel_t, flags: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetGpuLockedClocks( &self, device: nvmlDevice_t, minGpuClockMHz: c_uint, maxGpuClockMHz: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceResetGpuLockedClocks( &self, device: nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetMemoryLockedClocks( &self, device: nvmlDevice_t, minMemClockMHz: c_uint, maxMemClockMHz: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceResetMemoryLockedClocks( &self, device: nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetApplicationsClocks( &self, device: nvmlDevice_t, memClockMHz: c_uint, graphicsClockMHz: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetClkMonStatus( &self, device: nvmlDevice_t, status: *mut nvmlClkMonStatus_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetPowerManagementLimit( &self, device: nvmlDevice_t, limit: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetGpuOperationMode( &self, device: nvmlDevice_t, mode: nvmlGpuOperationMode_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetAPIRestriction( &self, device: nvmlDevice_t, apiType: nvmlRestrictedAPI_t, isRestricted: nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetFanSpeed_v2( &self, device: nvmlDevice_t, fan: c_uint, speed: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetGpcClkVfOffset( &self, device: nvmlDevice_t, offset: c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetMemClkVfOffset( &self, device: nvmlDevice_t, offset: c_int ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetConfComputeUnprotectedMemSize( &self, device: nvmlDevice_t, sizeKiB: c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlSystemSetConfComputeGpusReadyState( &self, isAcceptingWork: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetAccountingMode( &self, device: nvmlDevice_t, mode: nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceClearAccountingPids( &self, device: nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNvLinkState( &self, device: nvmlDevice_t, link: c_uint, isActive: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNvLinkVersion( &self, device: nvmlDevice_t, link: c_uint, version: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNvLinkCapability( &self, device: nvmlDevice_t, link: c_uint, capability: nvmlNvLinkCapability_t, capResult: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNvLinkRemotePciInfo_v2( &self, device: nvmlDevice_t, link: c_uint, pci: *mut nvmlPciInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNvLinkErrorCounter( &self, device: nvmlDevice_t, link: c_uint, counter: nvmlNvLinkErrorCounter_t, counterValue: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceResetNvLinkErrorCounters( &self, device: nvmlDevice_t, link: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetNvLinkUtilizationControl( &self, device: nvmlDevice_t, link: c_uint, counter: c_uint, control: *mut nvmlNvLinkUtilizationControl_t, reset: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNvLinkUtilizationControl( &self, device: nvmlDevice_t, link: c_uint, counter: c_uint, control: *mut nvmlNvLinkUtilizationControl_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNvLinkUtilizationCounter( &self, device: nvmlDevice_t, link: c_uint, counter: c_uint, rxcounter: *mut c_ulonglong, txcounter: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceFreezeNvLinkUtilizationCounter( &self, device: nvmlDevice_t, link: c_uint, counter: c_uint, freeze: nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceResetNvLinkUtilizationCounter( &self, device: nvmlDevice_t, link: c_uint, counter: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetNvLinkRemoteDeviceType( &self, device: nvmlDevice_t, link: c_uint, pNvLinkDeviceType: *mut nvmlIntNvLinkDeviceType_t ) -> nvmlReturn_t

pub unsafe fn nvmlEventSetCreate( &self, set: *mut nvmlEventSet_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceRegisterEvents( &self, device: nvmlDevice_t, eventTypes: c_ulonglong, set: nvmlEventSet_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSupportedEventTypes( &self, device: nvmlDevice_t, eventTypes: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlEventSetWait_v2( &self, set: nvmlEventSet_t, data: *mut nvmlEventData_t, timeoutms: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlEventSetFree(&self, set: nvmlEventSet_t) -> nvmlReturn_t

pub unsafe fn nvmlDeviceModifyDrainState( &self, pciInfo: *mut nvmlPciInfo_t, newState: nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceQueryDrainState( &self, pciInfo: *mut nvmlPciInfo_t, currentState: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceRemoveGpu_v2( &self, pciInfo: *mut nvmlPciInfo_t, gpuState: nvmlDetachGpuState_t, linkState: nvmlPcieLinkState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceDiscoverGpus( &self, pciInfo: *mut nvmlPciInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetFieldValues( &self, device: nvmlDevice_t, valuesCount: c_int, values: *mut nvmlFieldValue_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceClearFieldValues( &self, device: nvmlDevice_t, valuesCount: c_int, values: *mut nvmlFieldValue_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVirtualizationMode( &self, device: nvmlDevice_t, pVirtualMode: *mut nvmlGpuVirtualizationMode_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetHostVgpuMode( &self, device: nvmlDevice_t, pHostVgpuMode: *mut nvmlHostVgpuMode_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetVirtualizationMode( &self, device: nvmlDevice_t, virtualMode: nvmlGpuVirtualizationMode_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGridLicensableFeatures_v4( &self, device: nvmlDevice_t, pGridLicensableFeatures: *mut nvmlGridLicensableFeatures_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetProcessUtilization( &self, device: nvmlDevice_t, utilization: *mut nvmlProcessUtilizationSample_t, processSamplesCount: *mut c_uint, lastSeenTimeStamp: c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGspFirmwareVersion( &self, device: nvmlDevice_t, version: *mut c_char ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGspFirmwareMode( &self, device: nvmlDevice_t, isEnabled: *mut c_uint, defaultMode: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlGetVgpuDriverCapabilities( &self, capability: nvmlVgpuDriverCapability_t, capResult: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVgpuCapabilities( &self, device: nvmlDevice_t, capability: nvmlDeviceVgpuCapability_t, capResult: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetSupportedVgpus( &self, device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuTypeIds: *mut nvmlVgpuTypeId_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetCreatableVgpus( &self, device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuTypeIds: *mut nvmlVgpuTypeId_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetClass( &self, vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeClass: *mut c_char, size: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetName( &self, vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeName: *mut c_char, size: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetGpuInstanceProfileId( &self, vgpuTypeId: nvmlVgpuTypeId_t, gpuInstanceProfileId: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetDeviceID( &self, vgpuTypeId: nvmlVgpuTypeId_t, deviceID: *mut c_ulonglong, subsystemID: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetFramebufferSize( &self, vgpuTypeId: nvmlVgpuTypeId_t, fbSize: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetNumDisplayHeads( &self, vgpuTypeId: nvmlVgpuTypeId_t, numDisplayHeads: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetResolution( &self, vgpuTypeId: nvmlVgpuTypeId_t, displayIndex: c_uint, xdim: *mut c_uint, ydim: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetLicense( &self, vgpuTypeId: nvmlVgpuTypeId_t, vgpuTypeLicenseString: *mut c_char, size: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetFrameRateLimit( &self, vgpuTypeId: nvmlVgpuTypeId_t, frameRateLimit: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetMaxInstances( &self, device: nvmlDevice_t, vgpuTypeId: nvmlVgpuTypeId_t, vgpuInstanceCount: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetMaxInstancesPerVm( &self, vgpuTypeId: nvmlVgpuTypeId_t, vgpuInstanceCountPerVm: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetActiveVgpus( &self, device: nvmlDevice_t, vgpuCount: *mut c_uint, vgpuInstances: *mut nvmlVgpuInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetVmID( &self, vgpuInstance: nvmlVgpuInstance_t, vmId: *mut c_char, size: c_uint, vmIdType: *mut nvmlVgpuVmIdType_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetUUID( &self, vgpuInstance: nvmlVgpuInstance_t, uuid: *mut c_char, size: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetVmDriverVersion( &self, vgpuInstance: nvmlVgpuInstance_t, version: *mut c_char, length: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetFbUsage( &self, vgpuInstance: nvmlVgpuInstance_t, fbUsage: *mut c_ulonglong ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetLicenseStatus( &self, vgpuInstance: nvmlVgpuInstance_t, licensed: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetType( &self, vgpuInstance: nvmlVgpuInstance_t, vgpuTypeId: *mut nvmlVgpuTypeId_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetFrameRateLimit( &self, vgpuInstance: nvmlVgpuInstance_t, frameRateLimit: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetEccMode( &self, vgpuInstance: nvmlVgpuInstance_t, eccMode: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetEncoderCapacity( &self, vgpuInstance: nvmlVgpuInstance_t, encoderCapacity: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceSetEncoderCapacity( &self, vgpuInstance: nvmlVgpuInstance_t, encoderCapacity: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetEncoderStats( &self, vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, averageFps: *mut c_uint, averageLatency: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetEncoderSessions( &self, vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlEncoderSessionInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetFBCStats( &self, vgpuInstance: nvmlVgpuInstance_t, fbcStats: *mut nvmlFBCStats_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetFBCSessions( &self, vgpuInstance: nvmlVgpuInstance_t, sessionCount: *mut c_uint, sessionInfo: *mut nvmlFBCSessionInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetGpuInstanceId( &self, vgpuInstance: nvmlVgpuInstance_t, gpuInstanceId: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetGpuPciId( &self, vgpuInstance: nvmlVgpuInstance_t, vgpuPciId: *mut c_char, length: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuTypeGetCapabilities( &self, vgpuTypeId: nvmlVgpuTypeId_t, capability: nvmlVgpuCapability_t, capResult: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetMetadata( &self, vgpuInstance: nvmlVgpuInstance_t, vgpuMetadata: *mut nvmlVgpuMetadata_t, bufferSize: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVgpuMetadata( &self, device: nvmlDevice_t, pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, bufferSize: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlGetVgpuCompatibility( &self, vgpuMetadata: *mut nvmlVgpuMetadata_t, pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, compatibilityInfo: *mut nvmlVgpuPgpuCompatibility_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetPgpuMetadataString( &self, device: nvmlDevice_t, pgpuMetadata: *mut c_char, bufferSize: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVgpuSchedulerLog( &self, device: nvmlDevice_t, pSchedulerLog: *mut nvmlVgpuSchedulerLog_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVgpuSchedulerState( &self, device: nvmlDevice_t, pSchedulerState: *mut nvmlVgpuSchedulerGetState_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVgpuSchedulerCapabilities( &self, device: nvmlDevice_t, pCapabilities: *mut nvmlVgpuSchedulerCapabilities_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetVgpuSchedulerState( &self, device: nvmlDevice_t, pSchedulerState: *mut nvmlVgpuSchedulerSetState_t ) -> nvmlReturn_t

pub unsafe fn nvmlGetVgpuVersion( &self, supported: *mut nvmlVgpuVersion_t, current: *mut nvmlVgpuVersion_t ) -> nvmlReturn_t

pub unsafe fn nvmlSetVgpuVersion( &self, vgpuVersion: *mut nvmlVgpuVersion_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVgpuUtilization( &self, device: nvmlDevice_t, lastSeenTimeStamp: c_ulonglong, sampleValType: *mut nvmlValueType_t, vgpuInstanceSamplesCount: *mut c_uint, utilizationSamples: *mut nvmlVgpuInstanceUtilizationSample_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetVgpuProcessUtilization( &self, device: nvmlDevice_t, lastSeenTimeStamp: c_ulonglong, vgpuProcessSamplesCount: *mut c_uint, utilizationSamples: *mut nvmlVgpuProcessUtilizationSample_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetAccountingMode( &self, vgpuInstance: nvmlVgpuInstance_t, mode: *mut nvmlEnableState_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetAccountingPids( &self, vgpuInstance: nvmlVgpuInstance_t, count: *mut c_uint, pids: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetAccountingStats( &self, vgpuInstance: nvmlVgpuInstance_t, pid: c_uint, stats: *mut nvmlAccountingStats_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceClearAccountingPids( &self, vgpuInstance: nvmlVgpuInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlVgpuInstanceGetLicenseInfo_v2( &self, vgpuInstance: nvmlVgpuInstance_t, licenseInfo: *mut nvmlVgpuLicenseInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlGetExcludedDeviceCount( &self, deviceCount: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlGetExcludedDeviceInfoByIndex( &self, index: c_uint, info: *mut nvmlExcludedDeviceInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetMigMode( &self, device: nvmlDevice_t, mode: c_uint, activationStatus: *mut nvmlReturn_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMigMode( &self, device: nvmlDevice_t, currentMode: *mut c_uint, pendingMode: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuInstanceProfileInfo( &self, device: nvmlDevice_t, profile: c_uint, info: *mut nvmlGpuInstanceProfileInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuInstanceProfileInfoV( &self, device: nvmlDevice_t, profile: c_uint, info: *mut nvmlGpuInstanceProfileInfo_v2_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuInstancePossiblePlacements_v2( &self, device: nvmlDevice_t, profileId: c_uint, placements: *mut nvmlGpuInstancePlacement_t, count: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuInstanceRemainingCapacity( &self, device: nvmlDevice_t, profileId: c_uint, count: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceCreateGpuInstance( &self, device: nvmlDevice_t, profileId: c_uint, gpuInstance: *mut nvmlGpuInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceCreateGpuInstanceWithPlacement( &self, device: nvmlDevice_t, profileId: c_uint, placement: *const nvmlGpuInstancePlacement_t, gpuInstance: *mut nvmlGpuInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceDestroy( &self, gpuInstance: nvmlGpuInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuInstances( &self, device: nvmlDevice_t, profileId: c_uint, gpuInstances: *mut nvmlGpuInstance_t, count: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuInstanceById( &self, device: nvmlDevice_t, id: c_uint, gpuInstance: *mut nvmlGpuInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceGetInfo( &self, gpuInstance: nvmlGpuInstance_t, info: *mut nvmlGpuInstanceInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceGetComputeInstanceProfileInfo( &self, gpuInstance: nvmlGpuInstance_t, profile: c_uint, engProfile: c_uint, info: *mut nvmlComputeInstanceProfileInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceGetComputeInstanceProfileInfoV( &self, gpuInstance: nvmlGpuInstance_t, profile: c_uint, engProfile: c_uint, info: *mut nvmlComputeInstanceProfileInfo_v2_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceGetComputeInstanceRemainingCapacity( &self, gpuInstance: nvmlGpuInstance_t, profileId: c_uint, count: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceGetComputeInstancePossiblePlacements( &self, gpuInstance: nvmlGpuInstance_t, profileId: c_uint, placements: *mut nvmlComputeInstancePlacement_t, count: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceCreateComputeInstance( &self, gpuInstance: nvmlGpuInstance_t, profileId: c_uint, computeInstance: *mut nvmlComputeInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceCreateComputeInstanceWithPlacement( &self, gpuInstance: nvmlGpuInstance_t, profileId: c_uint, placement: *const nvmlComputeInstancePlacement_t, computeInstance: *mut nvmlComputeInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlComputeInstanceDestroy( &self, computeInstance: nvmlComputeInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceGetComputeInstances( &self, gpuInstance: nvmlGpuInstance_t, profileId: c_uint, computeInstances: *mut nvmlComputeInstance_t, count: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlGpuInstanceGetComputeInstanceById( &self, gpuInstance: nvmlGpuInstance_t, id: c_uint, computeInstance: *mut nvmlComputeInstance_t ) -> nvmlReturn_t

pub unsafe fn nvmlComputeInstanceGetInfo_v2( &self, computeInstance: nvmlComputeInstance_t, info: *mut nvmlComputeInstanceInfo_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceIsMigDeviceHandle( &self, device: nvmlDevice_t, isMigDevice: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetGpuInstanceId( &self, device: nvmlDevice_t, id: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetComputeInstanceId( &self, device: nvmlDevice_t, id: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMaxMigDeviceCount( &self, device: nvmlDevice_t, count: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetMigDeviceHandleByIndex( &self, device: nvmlDevice_t, index: c_uint, migDevice: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceGetDeviceHandleFromMigDeviceHandle( &self, migDevice: nvmlDevice_t, device: *mut nvmlDevice_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpmMetricsGet( &self, metricsGet: *mut nvmlGpmMetricsGet_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpmSampleFree( &self, gpmSample: nvmlGpmSample_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpmSampleAlloc( &self, gpmSample: *mut nvmlGpmSample_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpmSampleGet( &self, device: nvmlDevice_t, gpmSample: nvmlGpmSample_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpmMigSampleGet( &self, device: nvmlDevice_t, gpuInstanceId: c_uint, gpmSample: nvmlGpmSample_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpmQueryDeviceSupport( &self, device: nvmlDevice_t, gpmSupport: *mut nvmlGpmSupport_t ) -> nvmlReturn_t

pub unsafe fn nvmlGpmQueryIfStreamingEnabled( &self, device: nvmlDevice_t, state: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlGpmSetStreamingEnabled( &self, device: nvmlDevice_t, state: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetNvLinkDeviceLowPowerThreshold( &self, device: nvmlDevice_t, info: *mut nvmlNvLinkPowerThres_t ) -> nvmlReturn_t

pub unsafe fn nvmlSystemSetNvlinkBwMode( &self, nvlinkBwMode: c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlSystemGetNvlinkBwMode( &self, nvlinkBwMode: *mut c_uint ) -> nvmlReturn_t

pub unsafe fn nvmlDeviceSetPowerManagementLimit_v2( &self, device: nvmlDevice_t, powerValue: *mut nvmlPowerValue_v2_t ) -> nvmlReturn_t