/**
- * Author......: Jens Steube <jens.steube@gmail.com>
+ * Authors.....: Jens Steube <jens.steube@gmail.com>
+ * Gabriele Gristina <matrix@hashcat.net>
+ *
* License.....: MIT
*/
#include <ext_nvml.h>
-//#ifdef _POSIX // implied
+int nvml_init (NVML_PTR *nvml)
+{
+ if (!nvml) return (-1);
+
+ memset (nvml, 0, sizeof (NVML_PTR));
+
+ #ifdef _WIN
+ nvml->lib = hc_dlopen ("nvml.dll");
+
+ if (!nvml->lib)
+ {
+ DWORD BufferSize = 1024;
+
+ char *Buffer = (char *) mymalloc (BufferSize);
+
+ RegGetValue (HKEY_LOCAL_MACHINE, "SOFTWARE\\NVIDIA Corporation\\Global\\NVSMI", "NVSMIPATH", RRF_RT_ANY, NULL, (PVOID) Buffer, &BufferSize);
+
+ strcat (Buffer, "\\nvml.dll");
+
+ nvml->lib = hc_dlopen (Buffer);
+
+ myfree (Buffer);
+ }
-void *GetLibFunction (void *pLibrary, const char *name)
+ #elif _POSIX
+ nvml->lib = hc_dlopen ("libnvidia-ml.so", RTLD_NOW);
+ #endif
+
+ if (!nvml->lib)
+ {
+ if (data.quiet == 0)
+ log_info ("WARNING: NVML library load failed, proceed without NVML HWMon enabled.");
+
+ return (-1);
+ }
+
+ HC_LOAD_FUNC(nvml, nvmlErrorString, NVML_ERROR_STRING, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlInit, NVML_INIT, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlShutdown, NVML_SHUTDOWN, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetName, NVML_DEVICE_GET_NAME, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetHandleByIndex, NVML_DEVICE_GET_HANDLE_BY_INDEX, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetTemperature, NVML_DEVICE_GET_TEMPERATURE, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetFanSpeed, NVML_DEVICE_GET_FAN_SPEED, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetPowerUsage, NVML_DEVICE_GET_POWER_USAGE, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetUtilizationRates, NVML_DEVICE_GET_UTILIZATION_RATES, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetClockInfo, NVML_DEVICE_GET_CLOCKINFO, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetTemperatureThreshold, NVML_DEVICE_GET_THRESHOLD, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrPcieLinkGeneration, NVML_DEVICE_GET_CURRPCIELINKGENERATION, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrPcieLinkWidth, NVML_DEVICE_GET_CURRPCIELINKWIDTH, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrentClocksThrottleReasons, NVML_DEVICE_GET_CURRENTCLOCKSTHROTTLEREASONS, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetSupportedClocksThrottleReasons, NVML_DEVICE_GET_SUPPORTEDCLOCKSTHROTTLEREASONS, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceSetComputeMode, NVML_DEVICE_SET_COMPUTEMODE, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceSetGpuOperationMode, NVML_DEVICE_SET_OPERATIONMODE, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetPowerManagementLimitConstraints, NVML_DEVICE_GET_POWERMANAGEMENTLIMITCONSTRAINTS, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceSetPowerManagementLimit, NVML_DEVICE_SET_POWERMANAGEMENTLIMIT, NVML, 0)
+ HC_LOAD_FUNC(nvml, nvmlDeviceGetPowerManagementLimit, NVML_DEVICE_GET_POWERMANAGEMENTLIMIT, NVML, 0)
+
+ return 0;
+}
+
+void nvml_close (NVML_PTR *nvml)
{
- return dlsym (pLibrary, name);
+ if (nvml)
+ {
+ if (nvml->lib)
+ hc_dlclose (nvml->lib);
+
+ myfree (nvml);
+ }
}
-const char * hc_NVML_nvmlErrorString (HM_LIB hDLL, nvmlReturn_t nvml_rc)
+const char *hm_NVML_nvmlErrorString (NVML_PTR *nvml, nvmlReturn_t nvml_rc)
{
- NVML_ERROR_STRING nvmlErrorString = (NVML_ERROR_STRING) GetLibFunction (hDLL, "nvmlErrorString");
+ if (!nvml) return NULL;
- if (nvmlErrorString == NULL)
+ return nvml->nvmlErrorString (nvml_rc);
+}
+
+nvmlReturn_t hm_NVML_nvmlInit (NVML_PTR *nvml)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlInit ();
+
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlErrorString() is missing");
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlInit()", nvml_rc, string);
}
- return nvmlErrorString (nvml_rc);
+ return nvml_rc;
}
-nvmlReturn_t hc_NVML_nvmlInit (HM_LIB hDLL)
+nvmlReturn_t hm_NVML_nvmlShutdown (NVML_PTR *nvml)
{
- NVML_INIT nvmlInit = (NVML_INIT) GetLibFunction (hDLL, "nvmlInit");
+ if (!nvml) return -1;
- if (nvmlInit == NULL)
+ nvmlReturn_t nvml_rc = nvml->nvmlShutdown ();
+
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlInit() is missing");
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlShutdown()", nvml_rc, string);
}
- nvmlReturn_t nvml_rc = nvmlInit ();
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceGetName (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, char *name, unsigned int length)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetName (device, name, length);
if (nvml_rc != NVML_SUCCESS)
{
- const char *string = hc_NVML_nvmlErrorString (hDLL, nvml_rc);
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- log_info ("WARN: %s %d %s\n", "nvmlInit()", nvml_rc, string);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetName()", nvml_rc, string);
+ }
}
return nvml_rc;
}
-nvmlReturn_t hc_NVML_nvmlShutdown (HM_LIB hDLL)
+nvmlReturn_t hm_NVML_nvmlDeviceGetHandleByIndex (NVML_PTR *nvml, int skip_warnings, unsigned int index, nvmlDevice_t *device)
{
- NVML_SHUTDOWN nvmlShutdown = (NVML_SHUTDOWN) GetLibFunction (hDLL, "nvmlShutdown");
+ if (!nvml) return -1;
- if (nvmlShutdown == NULL)
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetHandleByIndex (index, device);
+
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlShutdown() is missing");
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetHandleByIndex()", nvml_rc, string);
+ }
}
- nvmlReturn_t nvml_rc = nvmlShutdown ();
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceGetTemperature (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int *temp)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetTemperature (device, sensorType, temp);
if (nvml_rc != NVML_SUCCESS)
{
- const char *string = hc_NVML_nvmlErrorString (hDLL, nvml_rc);
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- log_info ("WARN: %s %d %s\n", "nvmlShutdown()", nvml_rc, string);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetTemperature()", nvml_rc, string);
+ }
}
return nvml_rc;
}
-nvmlReturn_t hc_NVML_nvmlDeviceGetName (HM_LIB hDLL, nvmlDevice_t device, char *name, unsigned int length)
+nvmlReturn_t hm_NVML_nvmlDeviceGetFanSpeed (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned int *speed)
{
- NVML_DEVICE_GET_NAME nvmlDeviceGetName = (NVML_DEVICE_GET_NAME) GetLibFunction (hDLL, "nvmlDeviceGetName");
+ if (!nvml) return -1;
- if (nvmlDeviceGetName == NULL)
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetFanSpeed (device, speed);
+
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlDeviceGetName() is missing");
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetFanSpeed()", nvml_rc, string);
+ }
}
- nvmlReturn_t nvml_rc = nvmlDeviceGetName (device, name, length);
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceGetPowerUsage (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned int *power)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetPowerUsage (device, power);
if (nvml_rc != NVML_SUCCESS)
{
- const char *string = hc_NVML_nvmlErrorString (hDLL, nvml_rc);
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- log_info ("WARN: %s %d %s\n", "nvmlDeviceGetName()", nvml_rc, string);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetPowerUsage()", nvml_rc, string);
+ }
}
return nvml_rc;
}
-nvmlReturn_t hc_NVML_nvmlDeviceGetHandleByIndex (HM_LIB hDLL, int skip_warnings, unsigned int index, nvmlDevice_t *device)
+nvmlReturn_t hm_NVML_nvmlDeviceGetUtilizationRates (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, nvmlUtilization_t *utilization)
{
- NVML_DEVICE_GET_HANDLE_BY_INDEX nvmlDeviceGetHandleByIndex = (NVML_DEVICE_GET_HANDLE_BY_INDEX) GetLibFunction (hDLL, "nvmlDeviceGetHandleByIndex");
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetUtilizationRates (device, utilization);
- if (nvmlDeviceGetHandleByIndex == NULL)
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlDeviceGetHandleByIndex() is missing");
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetUtilizationRates()", nvml_rc, string);
+ }
}
- nvmlReturn_t nvml_rc = nvmlDeviceGetHandleByIndex (index, device);
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceGetClockInfo (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, nvmlClockType_t type, unsigned int *clock)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetClockInfo (device, type, clock);
if (nvml_rc != NVML_SUCCESS)
{
if (skip_warnings == 0)
{
- const char *string = hc_NVML_nvmlErrorString (hDLL, nvml_rc);
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- log_info ("WARN: %s %d %s\n", "nvmlDeviceGetHandleByIndex()", nvml_rc, string);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetClockInfo()", nvml_rc, string);
}
}
return nvml_rc;
}
-nvmlReturn_t hc_NVML_nvmlDeviceGetTemperature (HM_LIB hDLL, nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int *temp)
+nvmlReturn_t hm_NVML_nvmlDeviceGetTemperatureThreshold (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int *temp)
{
- NVML_DEVICE_GET_TEMPERATURE nvmlDeviceGetTemperature = (NVML_DEVICE_GET_TEMPERATURE) GetLibFunction (hDLL, "nvmlDeviceGetTemperature");
+ if (!nvml) return -1;
- if (nvmlDeviceGetTemperature == NULL)
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetTemperatureThreshold (device, thresholdType, temp);
+
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlDeviceGetTemperature() is missing");
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetTemperatureThreshold()", nvml_rc, string);
+ }
}
- nvmlReturn_t nvml_rc = nvmlDeviceGetTemperature (device, sensorType, temp);
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceGetCurrPcieLinkGeneration (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned int *currLinkGen)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetCurrPcieLinkGeneration (device, currLinkGen);
if (nvml_rc != NVML_SUCCESS)
{
- *temp = -1;
-
- //const char *string = hc_NVML_nvmlErrorString (hDLL, nvml_rc);
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- //log_info ("WARN: %s %d %s\n", "nvmlDeviceGetTemperature()", nvml_rc, string);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetCurrPcieLinkGeneration()", nvml_rc, string);
+ }
}
return nvml_rc;
}
-nvmlReturn_t hc_NVML_nvmlDeviceGetFanSpeed (HM_LIB hDLL, int skip_warnings, nvmlDevice_t device, unsigned int *speed)
+nvmlReturn_t hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned int *currLinkWidth)
{
- NVML_DEVICE_GET_FAN_SPEED nvmlDeviceGetFanSpeed = (NVML_DEVICE_GET_FAN_SPEED) GetLibFunction (hDLL, "nvmlDeviceGetFanSpeed");
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetCurrPcieLinkWidth (device, currLinkWidth);
- if (nvmlDeviceGetFanSpeed == NULL)
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlDeviceGetFanSpeed() is missing");
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetCurrPcieLinkWidth()", nvml_rc, string);
+ }
}
- nvmlReturn_t nvml_rc = nvmlDeviceGetFanSpeed (device, speed);
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned long long *clocksThrottleReasons)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetCurrentClocksThrottleReasons (device, clocksThrottleReasons);
if (nvml_rc != NVML_SUCCESS)
{
- *speed = -1;
-
if (skip_warnings == 0)
{
- const char *string = hc_NVML_nvmlErrorString (hDLL, nvml_rc);
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- log_info ("WARN: %s %d %s\n", "nvmlDeviceGetFanSpeed()", nvml_rc, string);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetCurrentClocksThrottleReasons()", nvml_rc, string);
}
}
return nvml_rc;
}
-/* only tesla following */
-
-nvmlReturn_t hc_NVML_nvmlDeviceGetPowerUsage (HM_LIB hDLL, nvmlDevice_t device, unsigned int *power)
+nvmlReturn_t hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned long long *supportedClocksThrottleReasons)
{
- NVML_DEVICE_GET_POWER_USAGE nvmlDeviceGetPowerUsage = (NVML_DEVICE_GET_POWER_USAGE) GetLibFunction (hDLL, "nvmlDeviceGetPowerUsage");
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetSupportedClocksThrottleReasons (device, supportedClocksThrottleReasons);
- if (nvmlDeviceGetPowerUsage == NULL)
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlDeviceGetPowerUsage() is missing");
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetSupportedClocksThrottleReasons()", nvml_rc, string);
+ }
}
- nvmlReturn_t nvml_rc = nvmlDeviceGetPowerUsage (device, power);
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceSetComputeMode (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, nvmlComputeMode_t mode)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceSetComputeMode (device, mode);
if (nvml_rc != NVML_SUCCESS)
{
- *power = -1;
-
- //const char *string = hc_NVML_nvmlErrorString (hDLL, nvml_rc);
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- //log_info ("WARN: %s %d %s\n", "nvmlDeviceGetPowerUsage()", nvml_rc, string);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceSetComputeMode()", nvml_rc, string);
+ }
}
return nvml_rc;
}
-nvmlReturn_t hc_NVML_nvmlDeviceGetUtilizationRates (HM_LIB hDLL, nvmlDevice_t device, nvmlUtilization_t *utilization)
+nvmlReturn_t hm_NVML_nvmlDeviceSetGpuOperationMode (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, nvmlGpuOperationMode_t mode)
{
- NVML_DEVICE_GET_UTILIZATION_RATES nvmlDeviceGetUtilizationRates = (NVML_DEVICE_GET_UTILIZATION_RATES) GetLibFunction (hDLL, "nvmlDeviceGetUtilizationRates");
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceSetGpuOperationMode (device, mode);
- if (nvmlDeviceGetUtilizationRates == NULL)
+ if (nvml_rc != NVML_SUCCESS)
{
- log_error ("ERROR: %s\n", "nvmlDeviceGetUtilizationRates() is missing");
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- exit (-1);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceSetGpuOperationMode()", nvml_rc, string);
+ }
}
- nvmlReturn_t nvml_rc = nvmlDeviceGetUtilizationRates (device, utilization);
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned int *minLimit, unsigned int *maxLimit)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetPowerManagementLimitConstraints (device, minLimit, maxLimit);
if (nvml_rc != NVML_SUCCESS)
{
- utilization->gpu = -1;
- utilization->memory = -1;
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
+
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetPowerManagementLimitConstraints()", nvml_rc, string);
+ }
+ }
+
+ return nvml_rc;
+}
+
+nvmlReturn_t hm_NVML_nvmlDeviceSetPowerManagementLimit (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned int limit)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceSetPowerManagementLimit (device, limit);
- //const char *string = hc_NVML_nvmlErrorString (hDLL, nvml_rc);
+ if (nvml_rc != NVML_SUCCESS)
+ {
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
- //log_info ("WARN: %s %d %s\n", "nvmlDeviceGetUtilizationRates()", nvml_rc, string);
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceSetPowerManagementLimit()", nvml_rc, string);
+ }
}
return nvml_rc;
}
-//#endif
+nvmlReturn_t hm_NVML_nvmlDeviceGetPowerManagementLimit (NVML_PTR *nvml, int skip_warnings, nvmlDevice_t device, unsigned int *limit)
+{
+ if (!nvml) return -1;
+
+ nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetPowerManagementLimit (device, limit);
+
+ if (nvml_rc != NVML_SUCCESS)
+ {
+ if (skip_warnings == 0)
+ {
+ const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc);
+
+ log_info ("WARN: %s %d %s\n", "nvmlDeviceGetPowerManagementLimit()", nvml_rc, string);
+ }
+ }
+
+ return nvml_rc;
+}
projects / hashcat.git / blobdiff