GOSTSec
/
ccminer-gostd-lite
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

nvml: cleanup and check api restrictions 

there was too much wrap_ prefixes, internal cleanup

SetAPIRestriction reports success but we can not query/set app clocks
master
Tanguy Pruvot 10 years ago
parent
c218c3f514
commit
56170bb32e
3 changed files with 171 additions and 111 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      ccminer.cpp
  2. 157
      nvml.cpp
  3. 117
      nvml.h

8
ccminer.cpp
Unescape View File

@ -63,7 +63,7 @@ int cuda_finddevice(char *name);
#include "nvml.h" #include "nvml.h"
#ifdef USE_WRAPNVML #ifdef USE_WRAPNVML
wrap_nvml_handle *hnvml = NULL; nvml_handle *hnvml = NULL;
#endif #endif
#ifdef __linux /* Linux specific policy and affinity management */ #ifdef __linux /* Linux specific policy and affinity management */
@ -407,7 +407,7 @@ void proper_exit(int reason)
#endif #endif
#ifdef USE_WRAPNVML #ifdef USE_WRAPNVML
if (hnvml) if (hnvml)
wrap_nvml_destroy(hnvml); nvml_destroy(hnvml);
#endif #endif
free(opt_syslog_pfx); free(opt_syslog_pfx);
free(opt_api_allow); free(opt_api_allow);
@ -2214,11 +2214,11 @@ int main(int argc, char *argv[])
#ifdef USE_WRAPNVML #ifdef USE_WRAPNVML
#ifndef WIN32 #ifndef WIN32
/* nvml is currently not the best choice on Windows (only in x64) */ /* nvml is currently not the best choice on Windows (only in x64) */
hnvml = wrap_nvml_create(); hnvml = nvml_create();
if (hnvml) if (hnvml)
applog(LOG_INFO, "NVML GPU monitoring enabled."); applog(LOG_INFO, "NVML GPU monitoring enabled.");
#else #else
if (wrap_nvapi_init() == 0) if (nvapi_init() == 0)
applog(LOG_INFO, "NVAPI GPU monitoring enabled."); applog(LOG_INFO, "NVAPI GPU monitoring enabled.");
#endif #endif
else else

157
nvml.cpp
Unescape View File

@ -31,7 +31,7 @@ int cuda_num_devices();
#ifdef USE_WRAPNVML #ifdef USE_WRAPNVML
extern wrap_nvml_handle *hnvml; extern nvml_handle *hnvml;
extern char driver_version[32]; extern char driver_version[32];
static uint32_t device_bus_ids[8] = { 0 }; static uint32_t device_bus_ids[8] = { 0 };
@ -77,10 +77,10 @@ static uint32_t device_bus_ids[8] = { 0 };
} }
#endif #endif
wrap_nvml_handle * wrap_nvml_create() nvml_handle * nvml_create()
{ {
int i=0; int i=0;
wrap_nvml_handle *nvmlh = NULL; nvml_handle *nvmlh = NULL;
#if defined(WIN32) #if defined(WIN32)
/* Windows (do not use slashes, else ExpandEnvironmentStrings will mix them) */ /* Windows (do not use slashes, else ExpandEnvironmentStrings will mix them) */
@ -106,45 +106,53 @@ wrap_nvml_handle * wrap_nvml_create()
return NULL; return NULL;
} }
nvmlh = (wrap_nvml_handle *) calloc(1, sizeof(wrap_nvml_handle)); nvmlh = (nvml_handle *) calloc(1, sizeof(nvml_handle));
nvmlh->nvml_dll = nvml_dll; nvmlh->nvml_dll = nvml_dll;
nvmlh->nvmlInit = (wrap_nvmlReturn_t (*)(void)) nvmlh->nvmlInit = (nvmlReturn_t (*)(void))
wrap_dlsym(nvmlh->nvml_dll, "nvmlInit_v2"); wrap_dlsym(nvmlh->nvml_dll, "nvmlInit_v2");
if (!nvmlh->nvmlInit) { if (!nvmlh->nvmlInit) {
nvmlh->nvmlInit = (wrap_nvmlReturn_t (*)(void)) nvmlh->nvmlInit = (nvmlReturn_t (*)(void))
wrap_dlsym(nvmlh->nvml_dll, "nvmlInit"); wrap_dlsym(nvmlh->nvml_dll, "nvmlInit");
} }
nvmlh->nvmlDeviceGetCount = (wrap_nvmlReturn_t (*)(int *)) nvmlh->nvmlDeviceGetCount = (nvmlReturn_t (*)(int *))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetCount_v2"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetCount_v2");
nvmlh->nvmlDeviceGetHandleByIndex = (wrap_nvmlReturn_t (*)(int, wrap_nvmlDevice_t *)) nvmlh->nvmlDeviceGetHandleByIndex = (nvmlReturn_t (*)(int, nvmlDevice_t *))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetHandleByIndex_v2"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetHandleByIndex_v2");
nvmlh->nvmlDeviceGetApplicationsClock = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, wrap_nvmlClockType_t, unsigned int *)) nvmlh->nvmlDeviceGetAPIRestriction = (nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t *))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetAPIRestriction");
nvmlh->nvmlDeviceSetAPIRestriction = (nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceSetAPIRestriction");
nvmlh->nvmlDeviceGetDefaultApplicationsClock = (nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int *clock))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetDefaultApplicationsClock");
nvmlh->nvmlDeviceGetApplicationsClock = (nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int *clocks))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetApplicationsClock"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetApplicationsClock");
nvmlh->nvmlDeviceGetClockInfo = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, wrap_nvmlClockType_t, unsigned int *)) nvmlh->nvmlDeviceSetApplicationsClocks = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int mem, unsigned int gpu))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceSetApplicationsClocks");
nvmlh->nvmlDeviceGetClockInfo = (nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int *clock))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetClockInfo"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetClockInfo");
nvmlh->nvmlDeviceGetPciInfo = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, wrap_nvmlPciInfo_t *)) nvmlh->nvmlDeviceGetPciInfo = (nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t *))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPciInfo"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPciInfo");
nvmlh->nvmlDeviceGetName = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, char *, int)) nvmlh->nvmlDeviceGetName = (nvmlReturn_t (*)(nvmlDevice_t, char *, int))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetName"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetName");
nvmlh->nvmlDeviceGetTemperature = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, int, unsigned int *)) nvmlh->nvmlDeviceGetTemperature = (nvmlReturn_t (*)(nvmlDevice_t, int, unsigned int *))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetTemperature"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetTemperature");
nvmlh->nvmlDeviceGetFanSpeed = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, unsigned int *)) nvmlh->nvmlDeviceGetFanSpeed = (nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetFanSpeed"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetFanSpeed");
nvmlh->nvmlDeviceGetPerformanceState = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, int *)) nvmlh->nvmlDeviceGetPerformanceState = (nvmlReturn_t (*)(nvmlDevice_t, int *))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPowerUsage"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetPowerUsage");
nvmlh->nvmlDeviceGetSerial = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, char *, unsigned int)) nvmlh->nvmlDeviceGetSerial = (nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetSerial"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetSerial");
nvmlh->nvmlDeviceGetUUID = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, char *, unsigned int)) nvmlh->nvmlDeviceGetUUID = (nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetUUID"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetUUID");
nvmlh->nvmlDeviceGetVbiosVersion = (wrap_nvmlReturn_t (*)(wrap_nvmlDevice_t, char *, unsigned int)) nvmlh->nvmlDeviceGetVbiosVersion = (nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))
wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetVbiosVersion"); wrap_dlsym(nvmlh->nvml_dll, "nvmlDeviceGetVbiosVersion");
nvmlh->nvmlSystemGetDriverVersion = (wrap_nvmlReturn_t (*)(char *, unsigned int)) nvmlh->nvmlSystemGetDriverVersion = (nvmlReturn_t (*)(char *, unsigned int))
wrap_dlsym(nvmlh->nvml_dll, "nvmlSystemGetDriverVersion"); wrap_dlsym(nvmlh->nvml_dll, "nvmlSystemGetDriverVersion");
nvmlh->nvmlErrorString = (char* (*)(wrap_nvmlReturn_t)) nvmlh->nvmlErrorString = (char* (*)(nvmlReturn_t))
wrap_dlsym(nvmlh->nvml_dll, "nvmlErrorString"); wrap_dlsym(nvmlh->nvml_dll, "nvmlErrorString");
nvmlh->nvmlShutdown = (wrap_nvmlReturn_t (*)()) nvmlh->nvmlShutdown = (nvmlReturn_t (*)())
wrap_dlsym(nvmlh->nvml_dll, "nvmlShutdown"); wrap_dlsym(nvmlh->nvml_dll, "nvmlShutdown");
if (nvmlh->nvmlInit == NULL || if (nvmlh->nvmlInit == NULL ||
@ -179,13 +187,14 @@ wrap_nvml_handle * wrap_nvml_create()
return NULL; return NULL;
} }
nvmlh->devs = (wrap_nvmlDevice_t *) calloc(nvmlh->nvml_gpucount, sizeof(wrap_nvmlDevice_t)); nvmlh->devs = (nvmlDevice_t *) calloc(nvmlh->nvml_gpucount, sizeof(nvmlDevice_t));
nvmlh->nvml_pci_domain_id = (unsigned int*) calloc(nvmlh->nvml_gpucount, sizeof(unsigned int)); nvmlh->nvml_pci_domain_id = (unsigned int*) calloc(nvmlh->nvml_gpucount, sizeof(unsigned int));
nvmlh->nvml_pci_bus_id = (unsigned int*) calloc(nvmlh->nvml_gpucount, sizeof(unsigned int)); nvmlh->nvml_pci_bus_id = (unsigned int*) calloc(nvmlh->nvml_gpucount, sizeof(unsigned int));
nvmlh->nvml_pci_device_id = (unsigned int*)calloc(nvmlh->nvml_gpucount, sizeof(unsigned int)); nvmlh->nvml_pci_device_id = (unsigned int*) calloc(nvmlh->nvml_gpucount, sizeof(unsigned int));
nvmlh->nvml_pci_subsys_id = (unsigned int*)calloc(nvmlh->nvml_gpucount, sizeof(unsigned int)); nvmlh->nvml_pci_subsys_id = (unsigned int*) calloc(nvmlh->nvml_gpucount, sizeof(unsigned int));
nvmlh->nvml_cuda_device_id = (int*) calloc(nvmlh->nvml_gpucount, sizeof(int)); nvmlh->nvml_cuda_device_id = (int*) calloc(nvmlh->nvml_gpucount, sizeof(int));
nvmlh->cuda_nvml_device_id = (int*) calloc(nvmlh->cuda_gpucount, sizeof(int)); nvmlh->cuda_nvml_device_id = (int*) calloc(nvmlh->cuda_gpucount, sizeof(int));
nvmlh->app_clocks = (nvmlEnableState_t*) calloc(nvmlh->nvml_gpucount, sizeof(nvmlEnableState_t));
/* Obtain GPU device handles we're going to need repeatedly... */ /* Obtain GPU device handles we're going to need repeatedly... */
for (i=0; i<nvmlh->nvml_gpucount; i++) { for (i=0; i<nvmlh->nvml_gpucount; i++) {
@ -195,12 +204,39 @@ wrap_nvml_handle * wrap_nvml_create()
/* Query PCI info for each NVML device, and build table for mapping of */ /* Query PCI info for each NVML device, and build table for mapping of */
/* CUDA device IDs to NVML device IDs and vice versa */ /* CUDA device IDs to NVML device IDs and vice versa */
for (i=0; i<nvmlh->nvml_gpucount; i++) { for (i=0; i<nvmlh->nvml_gpucount; i++) {
wrap_nvmlPciInfo_t pciinfo; nvmlPciInfo_t pciinfo;
nvmlh->nvmlDeviceGetPciInfo(nvmlh->devs[i], &pciinfo); nvmlh->nvmlDeviceGetPciInfo(nvmlh->devs[i], &pciinfo);
nvmlh->nvml_pci_domain_id[i] = pciinfo.domain; nvmlh->nvml_pci_domain_id[i] = pciinfo.domain;
nvmlh->nvml_pci_bus_id[i] = pciinfo.bus; nvmlh->nvml_pci_bus_id[i] = pciinfo.bus;
nvmlh->nvml_pci_device_id[i] = pciinfo.device; nvmlh->nvml_pci_device_id[i] = pciinfo.device;
nvmlh->nvml_pci_subsys_id[i] = pciinfo.pci_device_id; nvmlh->nvml_pci_subsys_id[i] = pciinfo.pci_device_id;
nvmlh->app_clocks[i] = NVML_FEATURE_UNKNOWN;
if (nvmlh->nvmlDeviceSetAPIRestriction) {
nvmlh->nvmlDeviceSetAPIRestriction(nvmlh->devs[i], NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS,
NVML_FEATURE_ENABLED);
/* there is only this API_SET_APPLICATION_CLOCKS on the 750 Ti (340.58) */
}
if (nvmlh->nvmlDeviceGetAPIRestriction) {
nvmlh->nvmlDeviceGetAPIRestriction(nvmlh->devs[i], NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS,
&nvmlh->app_clocks[i]);
if (nvmlh->app_clocks[i] == NVML_FEATURE_ENABLED && opt_debug) {
applog(LOG_DEBUG, "NVML application clock feature is allowed");
#if 0
uint32_t mem;
nvmlReturn_t rc;
rc = nvmlh->nvmlDeviceGetDefaultApplicationsClock(nvmlh->devs[i], NVML_CLOCK_MEM, &mem);
if (rc == NVML_SUCCESS)
applog(LOG_DEBUG, "nvmlDeviceGetDefaultApplicationsClock: mem %u", mem);
else
applog(LOG_DEBUG, "nvmlDeviceGetDefaultApplicationsClock: %s", nvmlh->nvmlErrorString(rc));
rc = nvmlh->nvmlDeviceSetApplicationsClocks(nvmlh->devs[i], mem, 1228000);
if (rc != NVML_SUCCESS)
applog(LOG_DEBUG, "nvmlDeviceSetApplicationsClocks: %s", nvmlh->nvmlErrorString(rc));
#endif
}
}
} }
/* build mapping of NVML device IDs to CUDA IDs */ /* build mapping of NVML device IDs to CUDA IDs */
@ -230,41 +266,41 @@ wrap_nvml_handle * wrap_nvml_create()
return nvmlh; return nvmlh;
} }
int wrap_nvml_get_gpucount(wrap_nvml_handle *nvmlh, int *gpucount) int nvml_get_gpucount(nvml_handle *nvmlh, int *gpucount)
{ {
*gpucount = nvmlh->nvml_gpucount; *gpucount = nvmlh->nvml_gpucount;
return 0; return 0;
} }
int wrap_cuda_get_gpucount(wrap_nvml_handle *nvmlh, int *gpucount) int cuda_get_gpucount(nvml_handle *nvmlh, int *gpucount)
{ {
*gpucount = nvmlh->cuda_gpucount; *gpucount = nvmlh->cuda_gpucount;
return 0; return 0;
} }
int wrap_nvml_get_gpu_name(wrap_nvml_handle *nvmlh, int cudaindex, char *namebuf, int bufsize) int nvml_get_gpu_name(nvml_handle *nvmlh, int cudaindex, char *namebuf, int bufsize)
{ {
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount) if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
return -1; return -1;
if (nvmlh->nvmlDeviceGetName(nvmlh->devs[gpuindex], namebuf, bufsize) != WRAPNVML_SUCCESS) if (nvmlh->nvmlDeviceGetName(nvmlh->devs[gpuindex], namebuf, bufsize) != NVML_SUCCESS)
return -1; return -1;
return 0; return 0;
} }
int wrap_nvml_get_tempC(wrap_nvml_handle *nvmlh, int cudaindex, unsigned int *tempC) int nvml_get_tempC(nvml_handle *nvmlh, int cudaindex, unsigned int *tempC)
{ {
wrap_nvmlReturn_t rc; nvmlReturn_t rc;
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount) if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
return -1; return -1;
rc = nvmlh->nvmlDeviceGetTemperature(nvmlh->devs[gpuindex], 0u /* NVML_TEMPERATURE_GPU */, tempC); rc = nvmlh->nvmlDeviceGetTemperature(nvmlh->devs[gpuindex], 0u /* NVML_TEMPERATURE_GPU */, tempC);
if (rc != WRAPNVML_SUCCESS) { if (rc != NVML_SUCCESS) {
return -1; return -1;
} }
@ -272,15 +308,15 @@ int wrap_nvml_get_tempC(wrap_nvml_handle *nvmlh, int cudaindex, unsigned int *te
} }
int wrap_nvml_get_fanpcnt(wrap_nvml_handle *nvmlh, int cudaindex, unsigned int *fanpcnt) int nvml_get_fanpcnt(nvml_handle *nvmlh, int cudaindex, unsigned int *fanpcnt)
{ {
wrap_nvmlReturn_t rc; nvmlReturn_t rc;
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount) if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
return -1; return -1;
rc = nvmlh->nvmlDeviceGetFanSpeed(nvmlh->devs[gpuindex], fanpcnt); rc = nvmlh->nvmlDeviceGetFanSpeed(nvmlh->devs[gpuindex], fanpcnt);
if (rc != WRAPNVML_SUCCESS) { if (rc != NVML_SUCCESS) {
return -1; return -1;
} }
@ -288,14 +324,14 @@ int wrap_nvml_get_fanpcnt(wrap_nvml_handle *nvmlh, int cudaindex, unsigned int *
} }
/* Not Supported on 750Ti 340.23 */ /* Not Supported on 750Ti 340.23 */
int wrap_nvml_get_power_usage(wrap_nvml_handle *nvmlh, int cudaindex, unsigned int *milliwatts) int nvml_get_power_usage(nvml_handle *nvmlh, int cudaindex, unsigned int *milliwatts)
{ {
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount) if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
return -1; return -1;
wrap_nvmlReturn_t res = nvmlh->nvmlDeviceGetPowerUsage(nvmlh->devs[gpuindex], milliwatts); nvmlReturn_t res = nvmlh->nvmlDeviceGetPowerUsage(nvmlh->devs[gpuindex], milliwatts);
if (res != WRAPNVML_SUCCESS) { if (res != NVML_SUCCESS) {
if (opt_debug) if (opt_debug)
applog(LOG_DEBUG, "nvmlDeviceGetPowerUsage: %s", nvmlh->nvmlErrorString(res)); applog(LOG_DEBUG, "nvmlDeviceGetPowerUsage: %s", nvmlh->nvmlErrorString(res));
return -1; return -1;
@ -305,14 +341,14 @@ int wrap_nvml_get_power_usage(wrap_nvml_handle *nvmlh, int cudaindex, unsigned i
} }
/* Not Supported on 750Ti 340.23 */ /* Not Supported on 750Ti 340.23 */
int wrap_nvml_get_pstate(wrap_nvml_handle *nvmlh, int cudaindex, int *pstate) int nvml_get_pstate(nvml_handle *nvmlh, int cudaindex, int *pstate)
{ {
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount) if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
return -1; return -1;
wrap_nvmlReturn_t res = nvmlh->nvmlDeviceGetPerformanceState(nvmlh->devs[gpuindex], pstate); nvmlReturn_t res = nvmlh->nvmlDeviceGetPerformanceState(nvmlh->devs[gpuindex], pstate);
if (res != WRAPNVML_SUCCESS) { if (res != NVML_SUCCESS) {
//if (opt_debug) //if (opt_debug)
// applog(LOG_DEBUG, "nvmlDeviceGetPerformanceState: %s", nvmlh->nvmlErrorString(res)); // applog(LOG_DEBUG, "nvmlDeviceGetPerformanceState: %s", nvmlh->nvmlErrorString(res));
return -1; return -1;
@ -321,7 +357,7 @@ int wrap_nvml_get_pstate(wrap_nvml_handle *nvmlh, int cudaindex, int *pstate)
return 0; return 0;
} }
int wrap_nvml_get_busid(wrap_nvml_handle *nvmlh, int cudaindex, int *busid) int nvml_get_busid(nvml_handle *nvmlh, int cudaindex, int *busid)
{ {
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount) if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
@ -331,17 +367,17 @@ int wrap_nvml_get_busid(wrap_nvml_handle *nvmlh, int cudaindex, int *busid)
return 0; return 0;
} }
int wrap_nvml_get_serial(wrap_nvml_handle *nvmlh, int cudaindex, char *sn, int maxlen) int nvml_get_serial(nvml_handle *nvmlh, int cudaindex, char *sn, int maxlen)
{ {
uint32_t subids = 0; uint32_t subids = 0;
char uuid[NVML_DEVICE_UUID_BUFFER_SIZE]; char uuid[NVML_DEVICE_UUID_BUFFER_SIZE];
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
wrap_nvmlReturn_t res; nvmlReturn_t res;
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount) if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
return -1; return -1;
res = nvmlh->nvmlDeviceGetSerial(nvmlh->devs[gpuindex], sn, maxlen); res = nvmlh->nvmlDeviceGetSerial(nvmlh->devs[gpuindex], sn, maxlen);
if (res == WRAPNVML_SUCCESS) { if (res == NVML_SUCCESS) {
return 0; return 0;
} }
@ -350,7 +386,7 @@ int wrap_nvml_get_serial(wrap_nvml_handle *nvmlh, int cudaindex, char *sn, int m
// todo: check if there is vendor id is inside // todo: check if there is vendor id is inside
memset(uuid, 0, sizeof(uuid)); memset(uuid, 0, sizeof(uuid));
res = nvmlh->nvmlDeviceGetUUID(nvmlh->devs[gpuindex], uuid, sizeof(uuid)-1); res = nvmlh->nvmlDeviceGetUUID(nvmlh->devs[gpuindex], uuid, sizeof(uuid)-1);
if (res != WRAPNVML_SUCCESS) { if (res != NVML_SUCCESS) {
if (opt_debug) if (opt_debug)
applog(LOG_DEBUG, "nvmlDeviceGetUUID: %s", nvmlh->nvmlErrorString(res)); applog(LOG_DEBUG, "nvmlDeviceGetUUID: %s", nvmlh->nvmlErrorString(res));
return -1; return -1;
@ -360,15 +396,15 @@ int wrap_nvml_get_serial(wrap_nvml_handle *nvmlh, int cudaindex, char *sn, int m
return 0; return 0;
} }
int wrap_nvml_get_bios(wrap_nvml_handle *nvmlh, int cudaindex, char *desc, int maxlen) int nvml_get_bios(nvml_handle *nvmlh, int cudaindex, char *desc, int maxlen)
{ {
uint32_t subids = 0; uint32_t subids = 0;
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount) if (gpuindex < 0 || gpuindex >= nvmlh->nvml_gpucount)
return -1; return -1;
wrap_nvmlReturn_t res = nvmlh->nvmlDeviceGetVbiosVersion(nvmlh->devs[gpuindex], desc, maxlen); nvmlReturn_t res = nvmlh->nvmlDeviceGetVbiosVersion(nvmlh->devs[gpuindex], desc, maxlen);
if (res != WRAPNVML_SUCCESS) { if (res != NVML_SUCCESS) {
if (opt_debug) if (opt_debug)
applog(LOG_DEBUG, "nvmlDeviceGetVbiosVersion: %s", nvmlh->nvmlErrorString(res)); applog(LOG_DEBUG, "nvmlDeviceGetVbiosVersion: %s", nvmlh->nvmlErrorString(res));
return -1; return -1;
@ -376,7 +412,7 @@ int wrap_nvml_get_bios(wrap_nvml_handle *nvmlh, int cudaindex, char *desc, int m
return 0; return 0;
} }
int wrap_nvml_get_info(wrap_nvml_handle *nvmlh, int cudaindex, uint16_t *vid, uint16_t *pid) int nvml_get_info(nvml_handle *nvmlh, int cudaindex, uint16_t *vid, uint16_t *pid)
{ {
uint32_t subids = 0; uint32_t subids = 0;
int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex]; int gpuindex = nvmlh->cuda_nvml_device_id[cudaindex];
@ -389,7 +425,7 @@ int wrap_nvml_get_info(wrap_nvml_handle *nvmlh, int cudaindex, uint16_t *vid, ui
return 0; return 0;
} }
int wrap_nvml_destroy(wrap_nvml_handle *nvmlh) int nvml_destroy(nvml_handle *nvmlh)
{ {
nvmlh->nvmlShutdown(); nvmlh->nvmlShutdown();
@ -401,6 +437,7 @@ int wrap_nvml_destroy(wrap_nvml_handle *nvmlh)
free(nvmlh->nvml_pci_subsys_id); free(nvmlh->nvml_pci_subsys_id);
free(nvmlh->nvml_cuda_device_id); free(nvmlh->nvml_cuda_device_id);
free(nvmlh->cuda_nvml_device_id); free(nvmlh->cuda_nvml_device_id);
free(nvmlh->app_clocks);
free(nvmlh->devs); free(nvmlh->devs);
free(nvmlh); free(nvmlh);
@ -581,7 +618,7 @@ int nvapi_getbios(unsigned int devNum, char *desc, unsigned int maxlen)
return 0; return 0;
} }
int wrap_nvapi_init() int nvapi_init()
{ {
int num_gpus = cuda_num_devices(); int num_gpus = cuda_num_devices();
NvAPI_Status ret = NvAPI_Initialize(); NvAPI_Status ret = NvAPI_Initialize();
@ -658,7 +695,7 @@ int gpu_fanpercent(struct cgpu_info *gpu)
{ {
unsigned int pct = 0; unsigned int pct = 0;
if (hnvml) { if (hnvml) {
wrap_nvml_get_fanpcnt(hnvml, gpu->gpu_id, &pct); nvml_get_fanpcnt(hnvml, gpu->gpu_id, &pct);
} }
#ifdef WIN32 #ifdef WIN32
else { else {
@ -679,7 +716,7 @@ float gpu_temp(struct cgpu_info *gpu)
float tc = 0.0; float tc = 0.0;
unsigned int tmp = 0; unsigned int tmp = 0;
if (hnvml) { if (hnvml) {
wrap_nvml_get_tempC(hnvml, gpu->gpu_id, &tmp); nvml_get_tempC(hnvml, gpu->gpu_id, &tmp);
tc = (float)tmp; tc = (float)tmp;
} }
#ifdef WIN32 #ifdef WIN32
@ -696,7 +733,7 @@ int gpu_pstate(struct cgpu_info *gpu)
int pstate = -1; int pstate = -1;
int support = -1; int support = -1;
if (hnvml) { if (hnvml) {
support = wrap_nvml_get_pstate(hnvml, gpu->gpu_id, &pstate); support = nvml_get_pstate(hnvml, gpu->gpu_id, &pstate);
} }
#ifdef WIN32 #ifdef WIN32
if (support == -1) { if (support == -1) {
@ -713,7 +750,7 @@ int gpu_busid(struct cgpu_info *gpu)
int busid = -1; int busid = -1;
int support = -1; int support = -1;
if (hnvml) { if (hnvml) {
support = wrap_nvml_get_busid(hnvml, gpu->gpu_id, &busid); support = nvml_get_busid(hnvml, gpu->gpu_id, &busid);
} }
#ifdef WIN32 #ifdef WIN32
if (support == -1) { if (support == -1) {
@ -729,7 +766,7 @@ unsigned int gpu_power(struct cgpu_info *gpu)
unsigned int mw = 0; unsigned int mw = 0;
int support = -1; int support = -1;
if (hnvml) { if (hnvml) {
support = wrap_nvml_get_power_usage(hnvml, gpu->gpu_id, &mw); support = nvml_get_power_usage(hnvml, gpu->gpu_id, &mw);
} }
#ifdef WIN32 #ifdef WIN32
if (support == -1) { if (support == -1) {
@ -753,9 +790,9 @@ int gpu_info(struct cgpu_info *gpu)
if (hnvml) { if (hnvml) {
gpu->nvml_id = (int8_t) hnvml->cuda_nvml_device_id[id]; gpu->nvml_id = (int8_t) hnvml->cuda_nvml_device_id[id];
wrap_nvml_get_info(hnvml, id, &gpu->gpu_vid, &gpu->gpu_pid); nvml_get_info(hnvml, id, &gpu->gpu_vid, &gpu->gpu_pid);
wrap_nvml_get_serial(hnvml, id, gpu->gpu_sn, sizeof(gpu->gpu_sn)); nvml_get_serial(hnvml, id, gpu->gpu_sn, sizeof(gpu->gpu_sn));
wrap_nvml_get_bios(hnvml, id, gpu->gpu_desc, sizeof(gpu->gpu_desc)); nvml_get_bios(hnvml, id, gpu->gpu_desc, sizeof(gpu->gpu_desc));
} }
#ifdef WIN32 #ifdef WIN32
gpu->nvapi_id = (int8_t) nvapi_dev_map[id]; gpu->nvapi_id = (int8_t) nvapi_dev_map[id];

117
nvml.h
Unescape View File

@ -17,16 +17,7 @@
#include "miner.h" #include "miner.h"
/* typedef void * nvmlDevice_t;
* Ugly hacks to avoid dependencies on the real nvml.h until it starts
* getting included with the CUDA toolkit or a GDK that's got a known
* install location, etc.
*/
typedef enum wrap_nvmlReturn_enum {
WRAPNVML_SUCCESS = 0
} wrap_nvmlReturn_t;
typedef void * wrap_nvmlDevice_t;
/* our own version of the PCI info struct */ /* our own version of the PCI info struct */
typedef struct { typedef struct {
@ -40,13 +31,40 @@ typedef struct {
unsigned int res1; unsigned int res1;
unsigned int res2; unsigned int res2;
unsigned int res3; unsigned int res3;
} wrap_nvmlPciInfo_t; } nvmlPciInfo_t;
typedef enum nvmlClockType_t { enum nvmlEnableState_t {
NVML_CLOCK_GRAPHICS = 0, NVML_FEATURE_DISABLED = 0,
NVML_CLOCK_SM = 1, NVML_FEATURE_ENABLED = 1,
NVML_CLOCK_MEM = 2 NVML_FEATURE_UNKNOWN = 2
} wrap_nvmlClockType_t; };
enum nvmlRestrictedAPI_t {
NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS = 0,
NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKS = 1,
NVML_RESTRICTED_API_COUNT = 2
};
enum nvmlReturn_t {
NVML_SUCCESS = 0,
NVML_ERROR_UNINITIALIZED = 1,
NVML_ERROR_INVALID_ARGUMENT = 2,
NVML_ERROR_NOT_SUPPORTED = 3,
NVML_ERROR_NO_PERMISSION = 4,
NVML_ERROR_ALREADY_INITIALIZED = 5,
NVML_ERROR_NOT_FOUND = 6,
NVML_ERROR_INSUFFICIENT_SIZE = 7,
NVML_ERROR_INSUFFICIENT_POWER = 8,
NVML_ERROR_DRIVER_NOT_LOADED = 9,
NVML_ERROR_TIMEOUT = 10,
NVML_ERROR_UNKNOWN = 999
};
enum nvmlClockType_t {
NVML_CLOCK_GRAPHICS = 0,
NVML_CLOCK_SM = 1,
NVML_CLOCK_MEM = 2
};
#define NVML_DEVICE_SERIAL_BUFFER_SIZE 30 #define NVML_DEVICE_SERIAL_BUFFER_SIZE 30
#define NVML_DEVICE_UUID_BUFFER_SIZE 80 #define NVML_DEVICE_UUID_BUFFER_SIZE 80
@ -66,46 +84,51 @@ typedef struct {
unsigned int *nvml_pci_subsys_id; unsigned int *nvml_pci_subsys_id;
int *nvml_cuda_device_id; /* map NVML dev to CUDA dev */ int *nvml_cuda_device_id; /* map NVML dev to CUDA dev */
int *cuda_nvml_device_id; /* map CUDA dev to NVML dev */ int *cuda_nvml_device_id; /* map CUDA dev to NVML dev */
wrap_nvmlDevice_t *devs; nvmlDevice_t *devs;
wrap_nvmlReturn_t (*nvmlInit)(void); nvmlEnableState_t *app_clocks;
wrap_nvmlReturn_t (*nvmlDeviceGetCount)(int *); nvmlReturn_t (*nvmlInit)(void);
wrap_nvmlReturn_t (*nvmlDeviceGetHandleByIndex)(int, wrap_nvmlDevice_t *); nvmlReturn_t (*nvmlDeviceGetCount)(int *);
wrap_nvmlReturn_t (*nvmlDeviceGetClockInfo)(wrap_nvmlDevice_t, wrap_nvmlClockType_t, unsigned int *); nvmlReturn_t (*nvmlDeviceGetHandleByIndex)(int, nvmlDevice_t *);
wrap_nvmlReturn_t (*nvmlDeviceGetApplicationsClock)(wrap_nvmlDevice_t, wrap_nvmlClockType_t, unsigned int *); nvmlReturn_t (*nvmlDeviceGetAPIRestriction)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t *);
wrap_nvmlReturn_t (*nvmlDeviceGetPciInfo)(wrap_nvmlDevice_t, wrap_nvmlPciInfo_t *); nvmlReturn_t (*nvmlDeviceSetAPIRestriction)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t);
wrap_nvmlReturn_t (*nvmlDeviceGetName)(wrap_nvmlDevice_t, char *, int); nvmlReturn_t (*nvmlDeviceGetDefaultApplicationsClock)(nvmlDevice_t, nvmlClockType_t, unsigned int *);
wrap_nvmlReturn_t (*nvmlDeviceGetTemperature)(wrap_nvmlDevice_t, int, unsigned int *); nvmlReturn_t (*nvmlDeviceGetApplicationsClock)(nvmlDevice_t, nvmlClockType_t, unsigned int *);
wrap_nvmlReturn_t (*nvmlDeviceGetFanSpeed)(wrap_nvmlDevice_t, unsigned int *); nvmlReturn_t (*nvmlDeviceSetApplicationsClocks)(nvmlDevice_t, unsigned int, unsigned int);
wrap_nvmlReturn_t (*nvmlDeviceGetPerformanceState)(wrap_nvmlDevice_t, int *); /* enum */ nvmlReturn_t (*nvmlDeviceGetClockInfo)(nvmlDevice_t, nvmlClockType_t, unsigned int *);
wrap_nvmlReturn_t (*nvmlDeviceGetPowerUsage)(wrap_nvmlDevice_t, unsigned int *); nvmlReturn_t (*nvmlDeviceGetPciInfo)(nvmlDevice_t, nvmlPciInfo_t *);
wrap_nvmlReturn_t (*nvmlDeviceGetSerial)(wrap_nvmlDevice_t, char *serial, unsigned int len); nvmlReturn_t (*nvmlDeviceGetName)(nvmlDevice_t, char *, int);
wrap_nvmlReturn_t (*nvmlDeviceGetUUID)(wrap_nvmlDevice_t, char *uuid, unsigned int len); nvmlReturn_t (*nvmlDeviceGetTemperature)(nvmlDevice_t, int, unsigned int *);
wrap_nvmlReturn_t (*nvmlDeviceGetVbiosVersion)(wrap_nvmlDevice_t, char *version, unsigned int len); nvmlReturn_t (*nvmlDeviceGetFanSpeed)(nvmlDevice_t, unsigned int *);
wrap_nvmlReturn_t (*nvmlSystemGetDriverVersion)(char *version, unsigned int len); nvmlReturn_t (*nvmlDeviceGetPerformanceState)(nvmlDevice_t, int *); /* enum */
char* (*nvmlErrorString)(wrap_nvmlReturn_t); nvmlReturn_t (*nvmlDeviceGetPowerUsage)(nvmlDevice_t, unsigned int *);
wrap_nvmlReturn_t (*nvmlShutdown)(void); nvmlReturn_t (*nvmlDeviceGetSerial)(nvmlDevice_t, char *serial, unsigned int len);
} wrap_nvml_handle; nvmlReturn_t (*nvmlDeviceGetUUID)(nvmlDevice_t, char *uuid, unsigned int len);
nvmlReturn_t (*nvmlDeviceGetVbiosVersion)(nvmlDevice_t, char *version, unsigned int len);
nvmlReturn_t (*nvmlSystemGetDriverVersion)(char *version, unsigned int len);
wrap_nvml_handle * wrap_nvml_create(); char* (*nvmlErrorString)(nvmlReturn_t);
int wrap_nvml_destroy(wrap_nvml_handle *nvmlh); nvmlReturn_t (*nvmlShutdown)(void);
} nvml_handle;
nvml_handle * nvml_create();
int nvml_destroy(nvml_handle *nvmlh);
/* /*
* Query the number of GPUs seen by NVML * Query the number of GPUs seen by NVML
*/ */
int wrap_nvml_get_gpucount(wrap_nvml_handle *nvmlh, int *gpucount); int nvml_get_gpucount(nvml_handle *nvmlh, int *gpucount);
/* /*
* Query the number of GPUs seen by CUDA * Query the number of GPUs seen by CUDA
*/ */
int wrap_cuda_get_gpucount(wrap_nvml_handle *nvmlh, int *gpucount); int cuda_get_gpucount(nvml_handle *nvmlh, int *gpucount);
/* /*
* query the name of the GPU model from the CUDA device ID * query the name of the GPU model from the CUDA device ID
* *
*/ */
int wrap_nvml_get_gpu_name(wrap_nvml_handle *nvmlh, int nvml_get_gpu_name(nvml_handle *nvmlh,
int gpuindex, int gpuindex,
char *namebuf, char *namebuf,
int bufsize); int bufsize);
@ -113,13 +136,13 @@ int wrap_nvml_get_gpu_name(wrap_nvml_handle *nvmlh,
/* /*
* Query the current GPU temperature (Celsius), from the CUDA device ID * Query the current GPU temperature (Celsius), from the CUDA device ID
*/ */
int wrap_nvml_get_tempC(wrap_nvml_handle *nvmlh, int nvml_get_tempC(nvml_handle *nvmlh,
int gpuindex, unsigned int *tempC); int gpuindex, unsigned int *tempC);
/* /*
* Query the current GPU fan speed (percent) from the CUDA device ID * Query the current GPU fan speed (percent) from the CUDA device ID
*/ */
int wrap_nvml_get_fanpcnt(wrap_nvml_handle *nvmlh, int nvml_get_fanpcnt(nvml_handle *nvmlh,
int gpuindex, unsigned int *fanpcnt); int gpuindex, unsigned int *fanpcnt);
/* /*
@ -129,7 +152,7 @@ int wrap_nvml_get_fanpcnt(wrap_nvml_handle *nvmlh,
* limited in some cases only to Tesla series GPUs. * limited in some cases only to Tesla series GPUs.
* If the query is run on an unsupported GPU, this routine will return -1. * If the query is run on an unsupported GPU, this routine will return -1.
*/ */
int wrap_nvml_get_power_usage(wrap_nvml_handle *nvmlh, int nvml_get_power_usage(nvml_handle *nvmlh,
int gpuindex, int gpuindex,
unsigned int *milliwatts); unsigned int *milliwatts);
@ -147,7 +170,7 @@ int gpu_info(struct cgpu_info *gpu);
/* nvapi functions */ /* nvapi functions */
#ifdef WIN32 #ifdef WIN32
int wrap_nvapi_init(); int nvapi_init();
#endif #endif
#endif /* USE_WRAPNVML */ #endif /* USE_WRAPNVML */

Write Preview
Loading…
Cancel
Save