- Added makefile native compilation target
- Added makefile install and uninstall targets
- Added autotuning engine and user-configurable tuning database
-- Added current engine clock and current memory clock to the status display
+- Added current engine clock, current memory clock and pci-e lanes to the status display
+- Added support for --gpu-temp-retain for nvidia devices on windows
- Added execution timer of the running kernel to the status display
- Added command prompt to quit at next restore checkpoint
- Added human-readable error message for the OpenCL error codes
- Created environment variable to inform NVidia OpenCL runtime to not create its own kernel cache
- Created environment variable to inform pocl OpenCL runtime to not create its own kernel cache
- Dropped special 64-bit rotate() handling for NV, it seems that they've added it to their OpenCL runtime
+- Disabled retain support by default, you can reactive it using --gpu-temp-retain
+- Completely get rid of HAVE_ADL, HAVE_NVML and HAVE_NVAPI in sources
#ifndef EXT_ADL_H
#define EXT_ADL_H
-#if defined(HAVE_HWMON) && defined(HAVE_ADL)
+#if defined(HAVE_HWMON)
#include <common.h>
int hm_ADL_Overdrive6_TargetTemperatureData_Get (ADL_PTR *adl, int iAdapterIndex, int *cur_temp, int *default_temp);
int hm_ADL_Overdrive6_TargetTemperatureRangeInfo_Get (ADL_PTR *adl, int iAdapterIndex, ADLOD6ParameterRange *lpTargetTemperatureInfo);
-#endif // HAVE_HWMON && HAVE_ADL
+#endif // HAVE_HWMON
#endif // EXT_ADL_H
#ifndef EXT_NVAPI_H
#define EXT_NVAPI_H
-#if defined(HAVE_HWMON) && defined(HAVE_NVAPI)
+#if defined(HAVE_HWMON)
#include <common.h>
#define NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER MAKE_NVAPI_VERSION(NV_GPU_DYNAMIC_PSTATES_INFO_EX,1)
#define NVAPI_MAX_COOLER_PER_GPU 20
+
#define GPU_COOLER_SETTINGS_VER 0x20000
+#define GPU_COOLER_LEVELS_VER 0x10000
// Used in NV_GPU_COOLER_SETTINGS
typedef struct
} NV_GPU_COOLER_SETTINGS;
+typedef struct
+{
+ NvS32 Level;
+ NvS32 Policy;
+
+} NvLevel;
+
+typedef struct
+{
+ NvU32 Version;
+ NvLevel Levels[NVAPI_MAX_COOLER_PER_GPU];
+
+} NV_GPU_COOLER_LEVELS;
+
#define NVAPI_MAX_GPU_PUBLIC_CLOCKS 32
typedef enum _NV_GPU_PUBLIC_CLOCK_ID
NVAPI_INTERFACE NvAPI_GPU_GetThermalSettings(NvPhysicalGpuHandle hPhysicalGpu, NvU32 sensorIndex, NV_GPU_THERMAL_SETTINGS *pThermalSettings);
NVAPI_INTERFACE NvAPI_GPU_GetTachReading(NvPhysicalGpuHandle hPhysicalGPU, NvU32 *pValue);
NVAPI_INTERFACE NvAPI_GPU_GetCoolerSettings(NvPhysicalGpuHandle hPhysicalGpu, NvU32 coolerIndex, NV_GPU_COOLER_SETTINGS *pCoolerSettings);
+NVAPI_INTERFACE NvAPI_GPU_SetCoolerLevels(NvPhysicalGpuHandle hPhysicalGpu, NvU32 coolerIndex, NV_GPU_COOLER_LEVELS *pCoolerLevels);
NVAPI_INTERFACE NvAPI_GPU_GetDynamicPstatesInfoEx(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_DYNAMIC_PSTATES_INFO_EX *pDynamicPstatesInfoEx);
NVAPI_INTERFACE NvAPI_GPU_GetAllClockFrequencies(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_CLOCK_FREQUENCIES *pClkFreqs);
NVAPI_INTERFACE NvAPI_GPU_GetCurrentPCIEDownstreamWidth(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pWidth);
typedef int (*NVAPI_GPU_GETTHERMALSETTINGS) (NvPhysicalGpuHandle, NvU32, NV_GPU_THERMAL_SETTINGS *);
typedef int (*NVAPI_GPU_GETTACHREADING) (NvPhysicalGpuHandle, NvU32 *);
typedef int (*NVAPI_GPU_GETCOOLERSETTINGS) (NvPhysicalGpuHandle, NvU32, NV_GPU_COOLER_SETTINGS *);
+typedef int (*NVAPI_GPU_SETCOOLERLEVELS) (NvPhysicalGpuHandle, NvU32, NV_GPU_COOLER_LEVELS *);
typedef int (*NVAPI_GPU_GETDYNAMICPSTATESINFOEX) (NvPhysicalGpuHandle, NV_GPU_DYNAMIC_PSTATES_INFO_EX *);
typedef int (*NVAPI_GPU_GETALLCLOCKFREQUENCIES) (NvPhysicalGpuHandle, NV_GPU_CLOCK_FREQUENCIES *);
typedef int (*NVAPI_GPU_GETCURRENTPCIEDOWNSTREAMWIDTH) (NvPhysicalGpuHandle, NvU32 *);
NVAPI_GPU_GETTHERMALSETTINGS NvAPI_GPU_GetThermalSettings;
NVAPI_GPU_GETTACHREADING NvAPI_GPU_GetTachReading;
NVAPI_GPU_GETCOOLERSETTINGS NvAPI_GPU_GetCoolerSettings;
+ NVAPI_GPU_SETCOOLERLEVELS NvAPI_GPU_SetCoolerLevels;
NVAPI_GPU_GETDYNAMICPSTATESINFOEX NvAPI_GPU_GetDynamicPstatesInfoEx;
NVAPI_GPU_GETALLCLOCKFREQUENCIES NvAPI_GPU_GetAllClockFrequencies;
NVAPI_GPU_GETCURRENTPCIEDOWNSTREAMWIDTH NvAPI_GPU_GetCurrentPCIEDownstreamWidth;
int hm_NvAPI_GPU_GetThermalSettings (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NvU32 sensorIndex, NV_GPU_THERMAL_SETTINGS *pThermalSettings);
int hm_NvAPI_GPU_GetTachReading (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGPU, NvU32 *pValue);
int hm_NvAPI_GPU_GetCoolerSettings (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NvU32 coolerIndex, NV_GPU_COOLER_SETTINGS *pCoolerSettings);
+int hm_NvAPI_GPU_SetCoolerLevels (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NvU32 coolerIndex, NV_GPU_COOLER_LEVELS *pCoolerLevels);
int hm_NvAPI_GPU_GetDynamicPstatesInfoEx (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_DYNAMIC_PSTATES_INFO_EX *pDynamicPstatesInfoEx);
int hm_NvAPI_GPU_GetAllClockFrequencies (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_CLOCK_FREQUENCIES *pClkFreqs);
int hm_NvAPI_GPU_GetCurrentPCIEDownstreamWidth (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pWidth);
int hm_NvAPI_GPU_GetPerfDecreaseInfo (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pPerfDecrInfo);
-#endif // HAVE_HWMON && HAVE_NVAPI
+#endif // HAVE_HWMON
#endif // EXT_NVAPI_H
#ifndef EXT_NVML_H
#define EXT_NVML_H
-#if defined(HAVE_HWMON) && defined(HAVE_NVML)
+#if defined(HAVE_HWMON)
#include <common.h>
nvmlReturn_t hm_NVML_nvmlDeviceGetCurrPcieLinkGeneration (NVML_PTR *nvml, nvmlDevice_t device, unsigned int *currLinkGen);
nvmlReturn_t hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (NVML_PTR *nvml, nvmlDevice_t device, unsigned int *currLinkWidth);
-#endif // HAVE_HWMON && HAVE_NVML
+#endif // HAVE_HWMON
#endif // EXT_NVML_H
#ifdef HAVE_HWMON
-#if defined(HAVE_NVML) || defined(HAVE_NVAPI)
int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX]);
-#endif
-#ifdef HAVE_ADL
int get_adapters_num_amd (void *adl, int *iNumberAdapters);
int hm_get_adapter_index_amd (hm_attrs_t *hm_device, u32 *valid_adl_device_list, int num_adl_adapters, LPAdapterInfo lpAdapterInfo);
// int hm_get_device_num (void *adl, HM_ADAPTER_AMD hm_adapter_index, int *hm_device_num);
// void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices);
-#endif // HAVE_ADL
int hm_get_threshold_slowdown_with_device_id (const uint device_id);
int hm_get_temperature_with_device_id (const uint device_id);
int hm_get_fanspeed_with_device_id (const uint device_id);
+int hm_get_fanpolicy_with_device_id (const uint device_id);
int hm_get_buslanes_with_device_id (const uint device_id);
int hm_get_utilization_with_device_id (const uint device_id);
int hm_get_memoryspeed_with_device_id (const uint device_id);
int hm_get_corespeed_with_device_id (const uint device_id);
int hm_get_throttle_with_device_id (const uint device_id);
-int hm_set_fanspeed_with_device_id_amd (const uint device_id, const int fanspeed);
+int hm_set_fanspeed_with_device_id_amd (const uint device_id, const int fanspeed, const int fanpolicy);
+
+#if defined(WIN)
+int hm_set_fanspeed_with_device_id_nvapi (const uint device_id, const int fanspeed, const int fanpolicy);
+#endif
+
+#if defined(LINUX)
+int hm_set_fanspeed_with_device_id_nvml (const uint device_id, const int fanspeed, const int fanpolicy);
+#endif
void hm_device_val_to_str (char *target_buf, int max_buf_size, char *suffix, int value);
#endif // HAVE_HWMON
{
union
{
- #ifdef HAVE_ADL
HM_ADAPTER_AMD amd;
- #endif
-
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
HM_ADAPTER_NV nv;
- #endif
} adapter_index;
int od_version;
- int fan_supported;
+
+ int fan_get_supported;
+ int fan_set_supported;
int gpu_temp_threshold_slowdown;
int gpu_temp_threshold_shutdown;
OPENCL_HEADERS_KHRONOS := deps/OpenCL-Headers
-##
-
-WITH_ADL := 1
-WITH_NVML := 1
-WITH_NVAPI := 1
-
##
## Native compiler paths
##
CFLAGS += -O2
else
CFLAGS += -DDEBUG -g -ggdb
-
ifeq ($(DEBUG),2)
CFLAGS += -fsanitize=address -fno-omit-frame-pointer
endif
-
endif
##
ifeq ($(UNAME),Darwin)
export MACOSX_DEPLOYMENT_TARGET=10.9
-
-BINARY_NATIVE := $(PROG_NAME).app
-
+BINARY_NATIVE := $(BINARY_NATIVE).app
CFLAGS_NATIVE := -D_POSIX -DOSX
CFLAGS_NATIVE += $(CFLAGS)
-
LFLAGS_NATIVE := -lpthread
-
-WITH_ADL := 0
-WITH_NVML := 0
endif # darwin
ifeq ($(UNAME),Linux)
CFLAGS_NATIVE := -D_POSIX -DLINUX
-
ifndef DEBUG
CFLAGS_NATIVE += -s
endif
-
CFLAGS_NATIVE += $(CFLAGS)
-
LFLAGS_NATIVE := -lpthread -ldl
-
-ifneq (,$(filter 1,$(WITH_ADL) $(WITH_NVML)))
CFLAGS_NATIVE += -DHAVE_HWMON
-
-ifeq ($(WITH_ADL),1)
-CFLAGS_NATIVE += -DHAVE_ADL
-endif
-
-ifeq ($(WITH_NVML),1)
-CFLAGS_NATIVE += -DHAVE_NVML
-endif
-endif
-
endif # linux
##
endif
CFLAGS_CROSS_LINUX += $(CFLAGS)
-CFLAGS_CROSS_LINUX +=
-
-ifneq (,$(filter 1,$(WITH_ADL) $(WITH_NVML)))
CFLAGS_CROSS_LINUX += -DHAVE_HWMON
-ifeq ($(WITH_ADL),1)
-CFLAGS_CROSS_LINUX += -DHAVE_ADL
-endif
-
-ifeq ($(WITH_NVML),1)
-CFLAGS_CROSS_LINUX += -DHAVE_NVML
-endif
-endif
-
-CFLAGS_CROSS_WIN := -D_WIN -DWIN -D__MSVCRT__ -D__USE_MINGW_ANSI_STDIO=1
+CFLAGS_CROSS_WIN := -D_WIN -DWIN -D__MSVCRT__ -D__USE_MINGW_ANSI_STDIO=1
ifndef DEBUG
CFLAGS_CROSS_WIN += -s
endif
CFLAGS_CROSS_WIN += $(filter-out -fsanitize=address,$(CFLAGS))
-
-ifneq (,$(filter 1,$(WITH_ADL) $(WITH_NVAPI)))
CFLAGS_CROSS_WIN += -DHAVE_HWMON
-ifeq ($(WITH_ADL),1)
-CFLAGS_CROSS_WIN += -DHAVE_ADL
-endif
-
-ifeq ($(WITH_NVAPI),1)
-CFLAGS_CROSS_WIN += -DHAVE_NVAPI
-endif
-endif
-
CFLAGS_CROSS_32 := -m32
CFLAGS_CROSS_64 := -m64
NATIVE_OBJS := obj/ext_OpenCL.NATIVE.o obj/shared.NATIVE.o obj/rp_kernel_on_cpu.NATIVE.o
-ifneq (,$(filter 1,$(WITH_ADL) $(WITH_NVML)))
-ifeq ($(WITH_ADL),1)
+ifeq ($(UNAME),Linux)
NATIVE_OBJS += obj/ext_ADL.NATIVE.o
-endif
-
-ifeq ($(WITH_NVML),1)
NATIVE_OBJS += obj/ext_nvml.NATIVE.o
endif
-endif
-
-LINUX_32_OBJS := obj/ext_OpenCL.LINUX.32.o obj/shared.LINUX.32.o obj/rp_kernel_on_cpu.LINUX.32.o
-LINUX_64_OBJS := obj/ext_OpenCL.LINUX.64.o obj/shared.LINUX.64.o obj/rp_kernel_on_cpu.LINUX.64.o
-
-WIN_32_OBJS := obj/ext_OpenCL.WIN.32.o obj/shared.WIN.32.o obj/rp_kernel_on_cpu.WIN.32.o
-WIN_64_OBJS := obj/ext_OpenCL.WIN.64.o obj/shared.WIN.64.o obj/rp_kernel_on_cpu.WIN.64.o
-
-ifeq ($(WITH_ADL),1)
-LINUX_32_OBJS += obj/ext_ADL.LINUX.32.o
-LINUX_64_OBJS += obj/ext_ADL.LINUX.64.o
-
-WIN_32_OBJS += obj/ext_ADL.WIN.32.o
-WIN_64_OBJS += obj/ext_ADL.WIN.64.o
-endif
-ifeq ($(WITH_NVML),1)
-LINUX_32_OBJS += obj/ext_nvml.LINUX.32.o
-LINUX_64_OBJS += obj/ext_nvml.LINUX.64.o
-endif
-
-ifeq ($(WITH_NVAPI),1)
-WIN_32_OBJS += obj/ext_nvapi.WIN.32.o
-WIN_64_OBJS += obj/ext_nvapi.WIN.64.o
-endif
+LINUX_32_OBJS := obj/ext_OpenCL.LINUX.32.o obj/shared.LINUX.32.o obj/rp_kernel_on_cpu.LINUX.32.o obj/ext_ADL.LINUX.32.o obj/ext_nvml.LINUX.32.o
+LINUX_64_OBJS := obj/ext_OpenCL.LINUX.64.o obj/shared.LINUX.64.o obj/rp_kernel_on_cpu.LINUX.64.o obj/ext_ADL.LINUX.64.o obj/ext_nvml.LINUX.64.o
+WIN_32_OBJS := obj/ext_OpenCL.WIN.32.o obj/shared.WIN.32.o obj/rp_kernel_on_cpu.WIN.32.o obj/ext_ADL.WIN.32.o obj/ext_nvapi.WIN.32.o
+WIN_64_OBJS := obj/ext_OpenCL.WIN.64.o obj/shared.WIN.64.o obj/rp_kernel_on_cpu.WIN.64.o obj/ext_ADL.WIN.64.o obj/ext_nvapi.WIN.64.o
+
##
## Targets: Global
##
HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetThermalSettings, NVAPI_GPU_GETTHERMALSETTINGS, nvapi_QueryInterface, 0xE3640A56, NVAPI, 0)
HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetTachReading, NVAPI_GPU_GETTACHREADING, nvapi_QueryInterface, 0x5F608315, NVAPI, 0)
HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetCoolerSettings, NVAPI_GPU_GETCOOLERSETTINGS, nvapi_QueryInterface, 0xDA141340, NVAPI, 0)
+ HC_LOAD_ADDR(nvapi, NvAPI_GPU_SetCoolerLevels, NVAPI_GPU_SETCOOLERLEVELS, nvapi_QueryInterface, 0x891FA0AE, NVAPI, 0)
HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetAllClockFrequencies, NVAPI_GPU_GETALLCLOCKFREQUENCIES, nvapi_QueryInterface, 0xDCB616C3, NVAPI, 0)
HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetCurrentPCIEDownstreamWidth, NVAPI_GPU_GETCURRENTPCIEDOWNSTREAMWIDTH, nvapi_QueryInterface, 0xD048C3B1, NVAPI, 0)
HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetPerfDecreaseInfo, NVAPI_GPU_GETPERFDECREASEINFO, nvapi_QueryInterface, 0x7F7F4600, NVAPI, 0)
return NvAPI_rc;
}
+int hm_NvAPI_GPU_SetCoolerLevels (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NvU32 coolerIndex, NV_GPU_COOLER_LEVELS *pCoolerLevels)
+{
+ if (!nvapi) return (-1);
+
+ NvAPI_Status NvAPI_rc = nvapi->NvAPI_GPU_SetCoolerLevels (hPhysicalGpu, coolerIndex, pCoolerLevels);
+
+ if (NvAPI_rc != NVAPI_OK)
+ {
+ NvAPI_ShortString string = { 0 };
+
+ hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string);
+
+ log_info ("WARN: %s %d %s\n", "NvAPI_GPU_SetCoolerLevels()", NvAPI_rc, string);
+ }
+
+ return NvAPI_rc;
+}
+
int hm_NvAPI_GPU_GetDynamicPstatesInfoEx (NVAPI_PTR *nvapi, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_DYNAMIC_PSTATES_INFO_EX *pDynamicPstatesInfoEx)
{
if (!nvapi) return (-1);
#define BITMAP_MAX 24
#define GPU_TEMP_DISABLE 0
#define GPU_TEMP_ABORT 90
-#define GPU_TEMP_RETAIN 70
+#define GPU_TEMP_RETAIN 0
#define WORKLOAD_PROFILE 2
#define KERNEL_ACCEL 0
#define KERNEL_LOOPS 0
#ifdef HAVE_HWMON
" --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
" --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
- #ifdef HAVE_ADL
" --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
#endif
- #endif
" --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
" -s, --skip | Num | Skip X words from the start | -s 1000000",
" -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
int slowdown_warnings = 0;
- // these variables are mainly used for fan control (AMD only)
+ // these variables are mainly used for fan control
int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
- #ifdef HAVE_ADL
int temp_threshold = 1; // degrees celcius
int fan_speed_min = 15; // in percentage
int fan_speed_max = 100;
- #endif // HAVE_ADL
time_t last_temp_check_time;
#endif // HAVE_HWMON
break;
}
- #ifdef HAVE_ADL
const int gpu_temp_retain = data.gpu_temp_retain;
- if (gpu_temp_retain) // VENDOR_ID_AMD implied
+ if (gpu_temp_retain)
{
- if (data.hm_device[device_id].fan_supported == 1)
+ if (data.hm_device[device_id].fan_set_supported == 1)
{
int temp_cur = temperature;
if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
{
- hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
+ if (device_param->device_vendor_id == VENDOR_ID_AMD)
+ {
+ hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new, 1);
+ }
+ else if (device_param->device_vendor_id == VENDOR_ID_NV)
+ {
+ #ifdef _WIN
+ hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
+ #endif
+ }
fan_speed_chgd[device_id] = 1;
}
}
}
}
- #endif // HAVE_ADL
}
hc_thread_mutex_unlock (mux_adl);
// wrapper around mymalloc for ADL
-#if defined(HAVE_HWMON) && defined(HAVE_ADL)
+#if defined(HAVE_HWMON)
void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
{
return mymalloc (iSize);
#ifdef HAVE_HWMON
uint gpu_temp_abort = GPU_TEMP_ABORT;
uint gpu_temp_retain = GPU_TEMP_RETAIN;
- #ifdef HAVE_ADL
uint powertune_enable = POWERTUNE_ENABLE;
#endif
- #endif
uint logfile_disable = LOGFILE_DISABLE;
uint segment_size = SEGMENT_SIZE;
uint scrypt_tmto = SCRYPT_TMTO;
#ifdef HAVE_HWMON
{"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
{"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
- #ifdef HAVE_ADL
{"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
- #endif
#endif // HAVE_HWMON
{"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
{"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
uint workload_profile_chgd = 0;
uint opencl_vector_width_chgd = 0;
- #if defined(HAVE_HWMON) && defined(HAVE_ADL)
- uint gpu_temp_retain_chgd = 0;
- uint gpu_temp_abort_chgd = 0;
- #endif
-
optind = 1;
optopt = 0;
option_index = 0;
kernel_loops_chgd = 1; break;
case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
#ifdef HAVE_HWMON
- case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
- #ifdef HAVE_ADL
- gpu_temp_abort_chgd = 1;
- #endif
- break;
- case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
- #ifdef HAVE_ADL
- gpu_temp_retain_chgd = 1;
- #endif
- break;
- #ifdef HAVE_ADL
+ case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
+ case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
- #endif
#endif // HAVE_HWMON
case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
data.skip = skip;
data.limit = limit;
#ifdef HAVE_HWMON
- #ifdef HAVE_ADL
data.powertune_enable = powertune_enable;
#endif
- #endif
data.logfile_disable = logfile_disable;
data.truecrypt_keyfiles = truecrypt_keyfiles;
data.veracrypt_keyfiles = veracrypt_keyfiles;
logfile_top_uint (outfile_format);
logfile_top_uint (potfile_disable);
logfile_top_string (potfile_path);
- #if defined(HAVE_HWMON) && defined(HAVE_ADL)
+ #if defined(HAVE_HWMON)
logfile_top_uint (powertune_enable);
#endif
logfile_top_uint (scrypt_tmto);
gpu_temp_disable = 1;
#ifdef HAVE_HWMON
- #ifdef HAVE_ADL
powertune_enable = 1;
#endif
- #endif
data.status_timer = status_timer;
data.restore_timer = restore_timer;
}
}
- /**
- * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
- */
-
- for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
- {
- cl_platform_id platform = platforms[platform_id];
-
- char platform_vendor[INFOSZ] = { 0 };
-
- hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
-
- #ifdef HAVE_HWMON
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
- if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
- {
- // make sure that we do not directly control the fan for NVidia
-
- gpu_temp_retain = 0;
-
- data.gpu_temp_retain = gpu_temp_retain;
- }
- #endif // HAVE_NVML || HAVE_NVAPI
- #endif
- }
-
/**
* OpenCL device types:
* In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
*/
#ifdef HAVE_HWMON
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
- hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
- #endif
-
- #ifdef HAVE_ADL
- hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
+ hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
+ hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
#endif
if (gpu_temp_disable == 0)
{
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
if (nvapi_init (nvapi) == 0)
pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
- if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
+ if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_get_supported = 1;
}
}
}
- #endif // WIN && HAVE_NVAPI
+ #endif // WIN
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
if (nvml_init (nvml) == 0)
{
unsigned int speed;
- if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
+ if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_get_supported = 1;
}
}
}
- #endif // LINUX && HAVE_NVML
+ #endif // LINUX
data.hm_amd = NULL;
- #ifdef HAVE_ADL
ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
if (adl_init (adl) == 0)
myfree (lpAdapterInfo);
}
}
- #endif // HAVE_ADL
if (data.hm_amd == NULL && data.hm_nv == NULL)
{
*/
#ifdef HAVE_HWMON
- int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
+ int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
+ int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
- #ifdef HAVE_ADL
ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
- #endif // ADL
#endif
/**
#endif
}
+ #ifdef HAVE_HWMON
+
/**
* HM devices: copy
*/
const uint platform_devices_id = device_param->platform_devices_id;
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (device_param->device_vendor_id == VENDOR_ID_NV)
{
memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
}
- #endif
- #ifdef HAVE_ADL
if (device_param->device_vendor_id == VENDOR_ID_AMD)
{
memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
}
- #endif
}
}
* Driver / ADL bug?
*/
- #ifdef HAVE_ADL
if (powertune_enable == 1)
{
hc_thread_mutex_lock (mux_adl);
hc_thread_mutex_unlock (mux_adl);
}
- #endif // HAVE_ADK
+
#endif // HAVE_HWMON
#ifdef DEBUG
run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
}
+ #if defined(HAVE_HWMON)
+
/**
* Store thermal target temperature so we can send a notice to user
*/
- #if defined(HAVE_HWMON)
if (gpu_temp_disable == 0)
{
const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown == -1) ? 100000 : gpu_temp_threshold_slowdown;
}
- #endif
/**
* Store initial fanspeed if gpu_temp_retain is enabled
*/
- #if defined(HAVE_HWMON) && defined(HAVE_ADL)
- int gpu_temp_retain_set = 0;
-
if (gpu_temp_disable == 0)
{
- if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
+ if (gpu_temp_retain != 0)
{
hc_thread_mutex_lock (mux_adl);
- if (data.hm_device[device_id].fan_supported == 1)
+ if (data.hm_device[device_id].fan_get_supported == 1)
{
- if (gpu_temp_retain_chgd == 0)
- {
- uint cur_temp = 0;
- uint default_temp = 0;
+ const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
+ const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
- int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
+ temp_retain_fanspeed_value[device_id] = fanspeed;
+ temp_retain_fanpolicy_value[device_id] = fanpolicy;
- if (ADL_rc == ADL_OK)
- {
- #define GPU_TEMP_RETAIN_ABORT_DIFF 15
+ // we also set it to tell the OS we take control over the fan and it's automatic controller
+ // if it was set to automatic. we do not control user-defined fanspeeds.
- const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
+ if (fanpolicy == 1)
+ {
+ data.hm_device[device_id].fan_set_supported = 1;
- // special case with multi gpu setups: always use minimum retain
+ int rc = -1;
- if (gpu_temp_retain_set == 0)
- {
- gpu_temp_retain = gpu_temp_retain_target;
- gpu_temp_retain_set = 1;
- }
- else
- {
- gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
- }
-
- if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
+ if (device_param->device_vendor_id == VENDOR_ID_AMD)
+ {
+ rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
+ }
+ else if (device_param->device_vendor_id == VENDOR_ID_NV)
+ {
+ #ifdef _WIN
+ rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
+ #endif
}
- }
-
- const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
- temp_retain_fanspeed_value[device_id] = fan_speed;
+ if (rc == 0)
+ {
+ data.hm_device[device_id].fan_set_supported = 1;
+ }
+ else
+ {
+ log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
- if (fan_speed == -1)
+ data.hm_device[device_id].fan_set_supported = 0;
+ }
+ }
+ else
{
- log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
-
- temp_retain_fanspeed_value[device_id] = 0;
+ data.hm_device[device_id].fan_set_supported = 0;
}
}
hc_thread_mutex_unlock (mux_adl);
}
- #endif // HAVE_HWMON && HAVE_ADL
+
+ #endif // HAVE_HWMON
}
data.kernel_power_all = kernel_power_all;
#ifdef HAVE_HWMON
if (gpu_temp_disable == 0)
{
- #ifdef HAVE_ADL
if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
{
hc_thread_mutex_lock (mux_adl);
if (device_param->skipped) continue;
- if (data.hm_device[device_id].fan_supported == 1)
+ if (data.hm_device[device_id].fan_set_supported == 1)
{
- int fanspeed = temp_retain_fanspeed_value[device_id];
+ int fanspeed = temp_retain_fanspeed_value[device_id];
+ int fanpolicy = temp_retain_fanpolicy_value[device_id];
- if (fanspeed == -1) continue;
+ if (fanpolicy == 1)
+ {
+ int rc = -1;
- int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
+ if (device_param->device_vendor_id == VENDOR_ID_AMD)
+ {
+ rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
+ }
+ else if (device_param->device_vendor_id == VENDOR_ID_NV)
+ {
+ #ifdef _WIN
+ rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 16);
+ #endif
+ }
- if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
+ if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
+ }
}
}
hc_thread_mutex_unlock (mux_adl);
}
- #endif // HAVE_ADL
}
- #ifdef HAVE_ADL
// reset power tuning
if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
hc_thread_mutex_unlock (mux_adl);
}
- #endif // HAVE_ADL
if (gpu_temp_disable == 0)
{
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.hm_nv)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
hm_NVML_nvmlShutdown (data.hm_nv);
nvml_close (data.hm_nv);
- #elif defined(WIN) && (HAVE_NVAPI)
+ #elif defined(WIN)
hm_NvAPI_Unload (data.hm_nv);
data.hm_nv = NULL;
}
- #endif
- #ifdef HAVE_ADL
if (data.hm_amd)
{
hm_ADL_Main_Control_Destroy (data.hm_amd);
adl_close (data.hm_amd);
+
data.hm_amd = NULL;
}
- #endif
}
#endif // HAVE_HWMON
#ifdef HAVE_HWMON
local_free (temp_retain_fanspeed_value);
- #ifdef HAVE_ADL
local_free (od_clock_mem_status);
local_free (od_power_control_status);
- #endif // ADL
#endif
global_free (devices_param);
*/
#ifdef HAVE_HWMON
-#if defined(_WIN) && defined(HAVE_NVAPI)
+
+#if defined(_WIN)
int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX])
{
NvU32 pGpuCount;
return (pGpuCount);
}
-#endif // _WIN && HAVE_NVAPI
+#endif // _WIN
-#if defined(LINUX) && defined(HAVE_NVML)
+#if defined(LINUX)
int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX])
{
int pGpuCount = 0;
return (pGpuCount);
}
-#endif // LINUX && HAVE_NVML
+#endif
-#ifdef HAVE_ADL
int get_adapters_num_amd (void *adl, int *iNumberAdapters)
{
if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR *) adl, iNumberAdapters) != ADL_OK) return -1;
if ((FanSpeedInfo.iFlags & ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ) &&
(FanSpeedInfo.iFlags & ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE))
{
- hm_device[opencl_device_index].fan_supported = 1;
+ hm_device[opencl_device_index].fan_get_supported = 1;
}
else
{
- hm_device[opencl_device_index].fan_supported = 0;
+ hm_device[opencl_device_index].fan_get_supported = 0;
}
}
else // od_version == 6
if (faninfo.iSpeedType & ADL_OD6_FANSPEED_TYPE_PERCENT)
{
- hm_device[opencl_device_index].fan_supported = 1;
+ hm_device[opencl_device_index].fan_get_supported = 1;
}
else
{
- hm_device[opencl_device_index].fan_supported = 0;
+ hm_device[opencl_device_index].fan_get_supported = 0;
}
}
}
return num_adl_adapters;
}
-#endif // HAVE_ADL
int hm_get_threshold_slowdown_with_device_id (const uint device_id)
{
if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
- #ifdef HAVE_ADL
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
{
if (data.hm_amd)
}
}
}
- #endif
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
int target = 0;
hm_NVML_nvmlDeviceGetTemperatureThreshold (data.hm_nv, data.hm_device[device_id].adapter_index.nv, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN, (unsigned int *) &target);
return target;
#endif
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
- #endif // WIN && HAVE_NVAPI
+ #endif // WIN
}
- #endif // HAVE_NVML || HAVE_NVAPI
return -1;
}
{
if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
- #ifdef HAVE_ADL
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
{
if (data.hm_amd)
}
}
}
- #endif
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
int temperature = 0;
hm_NVML_nvmlDeviceGetTemperature (data.hm_nv, data.hm_device[device_id].adapter_index.nv, NVML_TEMPERATURE_GPU, (uint *) &temperature);
return temperature;
#endif
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
NV_GPU_THERMAL_SETTINGS pThermalSettings;
pThermalSettings.version = NV_GPU_THERMAL_SETTINGS_VER;
if (hm_NvAPI_GPU_GetThermalSettings (data.hm_nv, data.hm_device[device_id].adapter_index.nv, 0, &pThermalSettings) != NVAPI_OK) return -1;
return pThermalSettings.sensor[0].currentTemp;
- #endif // WIN && HAVE_NVAPI
+ #endif // WIN
+ }
+
+ return -1;
+}
+
+int hm_get_fanpolicy_with_device_id (const uint device_id)
+{
+ if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
+
+ if (data.hm_device[device_id].fan_get_supported == 1)
+ {
+ if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
+ {
+ if (data.hm_amd)
+ {
+ if (data.hm_device[device_id].od_version == 5)
+ {
+ ADLFanSpeedValue lpFanSpeedValue;
+
+ memset (&lpFanSpeedValue, 0, sizeof (lpFanSpeedValue));
+
+ lpFanSpeedValue.iSize = sizeof (lpFanSpeedValue);
+ lpFanSpeedValue.iSpeedType = ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;
+
+ if (hm_ADL_Overdrive5_FanSpeed_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, 0, &lpFanSpeedValue) != ADL_OK) return -1;
+
+ return (lpFanSpeedValue.iFanSpeed & ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED) ? 0 : 1;
+ }
+ else // od_version == 6
+ {
+ return 1;
+ }
+ }
+ }
+
+ if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
+ {
+ #if defined(LINUX)
+ return 0;
+ #endif
+
+ #if defined(WIN)
+ return 1;
+ #endif
+ }
}
- #endif // HAVE_NVML || HAVE_NVAPI
return -1;
}
int hm_get_fanspeed_with_device_id (const uint device_id)
{
- // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
- if (data.hm_device[device_id].fan_supported == 1)
+ if (data.hm_device[device_id].fan_get_supported == 1)
{
- #ifdef HAVE_ADL
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
{
if (data.hm_amd)
}
}
}
- #endif // HAVE_ADL
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
int speed = 0;
hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, data.hm_device[device_id].adapter_index.nv, (uint *) &speed);
return speed;
#endif
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
NV_GPU_COOLER_SETTINGS pCoolerSettings;
pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
- hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, data.hm_device[device_id].adapter_index.nv, 0, &pCoolerSettings);
+ if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, data.hm_device[device_id].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_OK) return -1;
return pCoolerSettings.Cooler[0].CurrentLevel;
#endif
}
- #endif // HAVE_NVML || HAVE_NVAPI
}
return -1;
{
if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
- #ifdef HAVE_ADL
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
{
if (data.hm_amd)
return PMActivity.iCurrentBusLanes;
}
}
- #endif // HAVE_ADL
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
unsigned int currLinkWidth;
hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data.hm_nv, data.hm_device[device_id].adapter_index.nv, &currLinkWidth);
return currLinkWidth;
#endif
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
int Width;
if (hm_NvAPI_GPU_GetCurrentPCIEDownstreamWidth (data.hm_nv, data.hm_device[device_id].adapter_index.nv, (NvU32 *) &Width) != NVAPI_OK) return -1;
return Width;
#endif
}
- #endif // HAVE_NVML || HAVE_NVAPI
return -1;
}
{
if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
- #ifdef HAVE_ADL
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
{
if (data.hm_amd)
return PMActivity.iActivityPercent;
}
}
- #endif // HAVE_ADL
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
nvmlUtilization_t utilization;
hm_NVML_nvmlDeviceGetUtilizationRates (data.hm_nv, data.hm_device[device_id].adapter_index.nv, &utilization);
return utilization.gpu;
#endif
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx;
pDynamicPstatesInfoEx.version = NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER;
return pDynamicPstatesInfoEx.utilization[0].percentage;
#endif
}
- #endif // HAVE_NVML || HAVE_NVAPI
return -1;
}
{
if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
- #ifdef HAVE_ADL
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
{
if (data.hm_amd)
return PMActivity.iMemoryClock / 100;
}
}
- #endif // HAVE_ADL
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
unsigned int clock;
hm_NVML_nvmlDeviceGetClockInfo (data.hm_nv, data.hm_device[device_id].adapter_index.nv, NVML_CLOCK_MEM, &clock);
return clock;
#endif
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
NV_GPU_CLOCK_FREQUENCIES pClkFreqs = { 0 };
pClkFreqs.version = NV_GPU_CLOCK_FREQUENCIES_VER;
return pClkFreqs.domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].frequency / 1000;
#endif
}
- #endif // HAVE_NVML || HAVE_NVAPI
return -1;
}
{
if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
- #ifdef HAVE_ADL
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
{
if (data.hm_amd)
return PMActivity.iEngineClock / 100;
}
}
- #endif // HAVE_ADL
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
unsigned int clock;
hm_NVML_nvmlDeviceGetClockInfo (data.hm_nv, data.hm_device[device_id].adapter_index.nv, NVML_CLOCK_SM, &clock);
return clock;
#endif
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
NV_GPU_CLOCK_FREQUENCIES pClkFreqs = { 0 };
pClkFreqs.version = NV_GPU_CLOCK_FREQUENCIES_VER;
return pClkFreqs.domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].frequency / 1000;
#endif
}
- #endif // HAVE_NVML || HAVE_NVAPI
return -1;
}
{
if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) return -1;
- #ifdef HAVE_ADL
+ if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
+ {
- #endif // HAVE_ADL
+ }
- #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
{
- #if defined(LINUX) && defined(HAVE_NVML)
+ #if defined(LINUX)
#endif
- #if defined(WIN) && defined(HAVE_NVAPI)
+ #if defined(WIN)
NvU32 throttle = 0;
if (hm_NvAPI_GPU_GetPerfDecreaseInfo (data.hm_nv, data.hm_device[device_id].adapter_index.nv, &throttle) != NVAPI_OK) return -1;
return throttle;
#endif
}
- #endif // HAVE_NVML || HAVE_NVAPI
return -1;
}
-#ifdef HAVE_ADL
-int hm_set_fanspeed_with_device_id_amd (const uint device_id, const int fanspeed)
+int hm_set_fanspeed_with_device_id_amd (const uint device_id, const int fanspeed, const int fanpolicy)
{
- if (data.hm_device[device_id].fan_supported == 1)
+ if (data.hm_device[device_id].fan_set_supported == 1)
{
if (data.hm_amd)
{
lpFanSpeedValue.iSize = sizeof (lpFanSpeedValue);
lpFanSpeedValue.iSpeedType = ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;
- lpFanSpeedValue.iFlags = ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED;
+ lpFanSpeedValue.iFlags = (fanpolicy == 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED : 0;
lpFanSpeedValue.iFanSpeed = fanspeed;
if (hm_ADL_Overdrive5_FanSpeed_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, 0, &lpFanSpeedValue) != ADL_OK) return -1;
return -1;
}
-#endif
-// helper function for status display
-
-void hm_device_val_to_str (char *target_buf, int max_buf_size, char *suffix, int value)
+#if defined(WIN)
+int hm_set_fanspeed_with_device_id_nvapi (const uint device_id, const int fanspeed, const int fanpolicy)
{
- #define VALUE_NOT_AVAILABLE "N/A"
-
- if (value == -1)
+ if (data.hm_device[device_id].fan_set_supported == 1)
{
- snprintf (target_buf, max_buf_size, VALUE_NOT_AVAILABLE);
+ if (data.hm_nv)
+ {
+ NV_GPU_COOLER_LEVELS CoolerLevels = { 0 };
+
+ CoolerLevels.Version = GPU_COOLER_LEVELS_VER | sizeof (NV_GPU_COOLER_LEVELS);
+
+ CoolerLevels.Levels[0].Level = fanspeed;
+ CoolerLevels.Levels[0].Policy = fanpolicy;
+
+ if (hm_NvAPI_GPU_SetCoolerLevels (data.hm_nv, data.hm_device[device_id].adapter_index.nv, 0, &CoolerLevels) != NVAPI_OK) return -1;
+
+ return 0;
+ }
}
- else
+
+ return -1;
+}
+#endif
+
+#if defined(LINUX)
+int hm_set_fanspeed_with_device_id_nvml (const uint device_id, const int fanspeed, const int fanpolicy)
+{
+ if (data.hm_device[device_id].fan_set_supported == 1)
{
- snprintf (target_buf, max_buf_size, "%2d%s", value, suffix);
+ if (data.hm_nv)
+ {
+ // NVML does not support setting the fan speed... :((
+
+ if (fanspeed == fanpolicy) return -1; // makes the compiler happy
+ }
}
+
+ return -1;
}
+#endif
+
#endif // HAVE_HWMON
/**
projects / hashcat.git / commitdiff