public Nvidia(uint i, nvmlDevice device)
{
this.deviceIndex = i;
this.device = device;
this.type = GPUType.NVIDIA;
nvmlPciInfo pciInfo = new nvmlPciInfo();
if (NvmlNativeMethods.nvmlDeviceGetPciInfo(device, ref pciInfo) == nvmlReturn.Success)
{
this.bus = pciInfo.bus;
}
if (NvmlNativeMethods.nvmlDeviceGetSerial(device, out string serialOut) == nvmlReturn.Success)
{
this.serial = serialOut;
}
if (NvmlNativeMethods.nvmlDeviceGetUUID(device, out string uuidOut) == nvmlReturn.Success)
{
this.uuid = uuidOut;
}
if (NvmlNativeMethods.nvmlDeviceGetName(device, out string name) == nvmlReturn.Success)
{
this.name = name;
}
NVAPIhandle = this.FindPhysicalGpuHandleForBus(this.bus);
}
//TODO fix constructor to not include 3rd party handles + refactor inside interface device info (lookup fans speed/temps/...)
public CudaComputeDevice(CudaDevice cudaDevice, DeviceGroupType group, int gpuCount,
NvPhysicalGpuHandle nvHandle, nvmlDevice nvmlHandle)
: base((int)cudaDevice.DeviceID,
cudaDevice.GetName(),
true,
group,
DeviceType.NVIDIA,
string.Format(Translations.Tr("GPU#{0}"), gpuCount),
cudaDevice.DeviceGlobalMemory)
{
BusID = cudaDevice.pciBusID;
SMMajor = cudaDevice.SM_major;
SMMinor = cudaDevice.SM_minor;
Uuid = cudaDevice.UUID;
AlgorithmSettings = DefaultAlgorithms.GetAlgorithmsForDevice(this);
Index = ID + AvailableDevices.AvailCpus; // increment by CPU count
_nvHandle = nvHandle;
_nvmlDevice = nvmlHandle;
ShouldRunEthlargement = cudaDevice.DeviceName.Contains("1080") || cudaDevice.DeviceName.Contains("Titan Xp");
// plugin device
var bd = new BaseDevice(DeviceType.NVIDIA, cudaDevice.UUID, cudaDevice.GetName(), (int)cudaDevice.DeviceID);
PluginDevice = new CUDADevice(bd, cudaDevice.pciBusID, cudaDevice.DeviceGlobalMemory, cudaDevice.SM_major, cudaDevice.SM_minor);
}
//TODO fix constructor to not include 3rd party handles + refactor inside interface device info (lookup fans speed/temps/...)
public CudaComputeDevice(CudaDevice cudaDevice, DeviceGroupType group, int gpuCount,
NvPhysicalGpuHandle nvHandle, nvmlDevice nvmlHandle)
: base((int)cudaDevice.DeviceID,
cudaDevice.GetName(),
true,
group,
DeviceType.NVIDIA,
string.Format(Translations.Tr("GPU#{0}"), gpuCount),
cudaDevice.DeviceGlobalMemory)
{
BusID = cudaDevice.pciBusID;
SMMajor = cudaDevice.SM_major;
SMMinor = cudaDevice.SM_minor;
// if no nvml loaded fallback ID
if (string.IsNullOrEmpty(cudaDevice.UUID))
{
Uuid = GetUuid(ID, GroupNames.GetGroupName(DeviceGroupType, ID), Name, DeviceGroupType);
}
else
{
Uuid = cudaDevice.UUID;
}
AlgorithmSettings = DefaultAlgorithms.GetAlgorithmsForDevice(this);
Index = ID + AvailableDevices.AvailCpus; // increment by CPU count
_nvHandle = nvHandle;
_nvmlDevice = nvmlHandle;
ShouldRunEthlargement = cudaDevice.DeviceName.Contains("1080") || cudaDevice.DeviceName.Contains("Titan Xp");
}
internal static void LogNvidiaMonitorManagerState()
{
// Enumerate NVAPI handles and map to busid
var idHandles = InitNvapi();
foreach (var pair in _nvidiaUUIDAndBusIds)
{
var uuid = pair.Key;
var busID = pair.Value;
var nvmlResultStr = "InitalNVMLInitSuccess==FALSE";
if (InitalNVMLInitSuccess)
{
var nvmlHandle = new nvmlDevice();
var nvmlRet = NvmlNativeMethods.nvmlDeviceGetHandleByUUID(uuid, ref nvmlHandle);
if (nvmlRet != nvmlReturn.Success)
{
nvmlResultStr = $"Failed with code ret {nvmlRet}";
}
else
{
nvmlResultStr = nvmlHandle.Pointer.ToString();
}
}
var nvapiResultStr = "NVAPI found no handle";
var nvHandle = new NvPhysicalGpuHandle();
if (idHandles.TryGetValue(busID, out nvHandle))
{
nvapiResultStr = nvHandle.ptr.ToString();
}
Logger.Info($"{Tag}.Init", $"UUID({uuid})-BusID({busID}): NVML_HANDLE({nvmlResultStr}) NVAPI_HANDLE({nvapiResultStr})");
}
}
private NVAPIService()
{
DllImportAttribute attribute = new DllImportAttribute(GetLibraryName());
attribute.CallingConvention = CallingConvention.Cdecl;
attribute.PreserveSig = true;
attribute.EntryPoint = "nvapi_QueryInterface";
PInvokeDelegateFactory.CreateDelegate(attribute, out nvapi_QueryInterface);
GetNvAPIDelegate(0x0150E828, out NvAPI_Initialize);
NvAPI_Initialize();
GetNvAPIDelegate(0xE5AC921F, out NvAPI_EnumPhysicalGPUs);
GetNvAPIDelegate(0xD9930B07, out NvAPI_EnumTCCPhysicalGPUs);
GetNvAPIDelegate(0x9ABDD40D, out NvAPI_EnumNvidiaDisplayHandle);
GetNvAPIDelegate(0x34EF9506, out NvAPI_GetPhysicalGPUsFromDisplay);
GetNvAPIDelegate(0x1BE0B8E5, out NvAPI_GPU_GetBusId);
GetNvAPIDelegate(0xE3640A56, out NvAPI_GPU_GetThermalSettings);
GetNvAPIDelegate(0x60DED2ED, out NvAPI_GPU_GetDynamicPstatesInfoEx);
GetNvAPIDelegate(0x189A1FDF, out NvAPI_GPU_GetDynamicPstatesInfo);
{
NvPhysicalGpuHandle[] physicalGpuHandles = new NvPhysicalGpuHandle[MAX_PHYSICAL_GPUS];
if (NvAPI_EnumPhysicalGPUs(physicalGpuHandles, out int physicalGpuCount) == 0)
{
nvPhysicalGpuHandles.AddRange(physicalGpuHandles.Where((handle, i) => i < physicalGpuCount && handle.IsValid).ToList());
}
NvPhysicalGpuHandle[] TCCPhysicalGpuHandles = new NvPhysicalGpuHandle[MAX_PHYSICAL_GPUS];
if (NvAPI_EnumTCCPhysicalGPUs(TCCPhysicalGpuHandles, out int TCCPhysicalGpuCount) == 0)
{
nvPhysicalGpuHandles.AddRange(TCCPhysicalGpuHandles.Where((handle, i) => i < TCCPhysicalGpuCount && handle.IsValid).ToList());
}
}
}
public NvidiaGpuModel(int adapterIndex, NvPhysicalGpuHandle handle, NvDisplayHandle displayHandle)
{
AdapterIndex = adapterIndex;
_handle = handle;
_displayHandle = displayHandle;
NVAPI.NvAPI_GPU_GetFullName(handle, out _gpuName);
}
public override bool InitializeHardware()
{
Logger.Debug("Initializing hardware ...");
if (NvApi.NvApiEnumPhysicalGpUs == null || NvApi.NvApiGetPhysicalGpUsFromDisplay == null || NvApi.NvApiEnumNvidiaDisplayHandle == null)
{
Logger.Debug("Unable to init hardware, NvApiEnumPhysicalGpUs, NvApiEnumNvidiaDisplayHandle and NvApiGetPhysicalGpUsFromDisplay are null pointer");
return(false);
}
NvStatus status;
var handles = new NvPhysicalGpuHandle[NvApi.MaxPhysicalGpus];
if ((status = NvApi.NvApiEnumPhysicalGpUs(handles, out var gpuCount)) != NvStatus.Ok)
{
Logger.Error($"Unable to enumerate physical gpus, the API status is: {status}");
return(false);
}
for (var gpuIndex = 0; gpuIndex < gpuCount; gpuIndex++)
{
var ngpu = new NVidiaGpu(gpuIndex, handles[gpuIndex]);
Logger.Debug($"Adding GPU {ngpu}");
ngpu.InitializeSensors();
Hardware.Add(ngpu);
}
return(true);
}
public static NvStatus NvAPI_GPU_GetFullName(NvPhysicalGpuHandle gpuHandle, out string name)
{
StringBuilder builder = new StringBuilder(SHORT_STRING_MAX);
NvStatus status = _nvAPI_GPU_GetFullName?.Invoke(gpuHandle, builder) ?? NvStatus.FUNCTION_NOT_FOUND;
name = builder.ToString();
return(status);
}
public static NvStatus NvAPI_GPU_GetFullName(NvPhysicalGpuHandle gpuHandle, out string name)
{
StringBuilder builder = new(SHORT_STRING_MAX);
NvStatus status = _nvAPI_GPU_GetFullName?.Invoke(gpuHandle, builder) ?? NvStatus.FunctionNotFound;
name = builder.ToString();
return(status);
}
internal DeviceMonitorNVIDIA(NvapiNvmlInfo info)
{
UUID = info.UUID;
BusID = info.BusID;
_nvHandle = info.nvHandle;
_nvmlDevice = info.nvmlHandle;
try
{
var powerInfo = new NvGPUPowerInfo
{
Version = NVAPI.GPU_POWER_INFO_VER,
Entries = new NvGPUPowerInfoEntry[4]
};
var ret = NVAPI.NvAPI_DLL_ClientPowerPoliciesGetInfo(_nvHandle, ref powerInfo);
if (ret != NvStatus.OK)
{
throw new Exception(ret.ToString());
}
Debug.Assert(powerInfo.Entries.Length == 4);
if (powerInfo.Entries[0].MinPower == 0 || powerInfo.Entries[0].MaxPower == 0)
{
throw new Exception("Power control not available!");
}
_minPowerLimit = powerInfo.Entries[0].MinPower;
_maxPowerLimit = powerInfo.Entries[0].MaxPower;
_defaultPowerLimit = powerInfo.Entries[0].DefPower;
PowerLimitsEnabled = true;
// set to high by default
var defaultLevel = PowerLevel.High;
if (!DeviceMonitorManager.DisableDevicePowerModeSettings)
{
var success = SetPowerTarget(defaultLevel);
if (!success)
{
Logger.Info("NVML", $"Cannot set power target ({defaultLevel.ToString()}) for device with BusID={BusID}");
}
}
else
{
PowerLevel = PowerLevel.Disabled;
}
}
catch (Exception e)
{
Logger.Error("NVML", $"Getting power info failed with message \"{e.Message}\", disabling power setting");
PowerLimitsEnabled = false;
}
}
public static NvStatus NvAPI_GPU_GetFullName(NvPhysicalGpuHandle gpuHandle,
out string name)
{
StringBuilder builder = new StringBuilder(64);
NvStatus status;
if (_NvAPI_GPU_GetFullName != null)
status = _NvAPI_GPU_GetFullName(gpuHandle, builder);
else
status = NvStatus.FUNCTION_NOT_FOUND;
name = builder.ToString();
return status;
}
private static string GetName(NvPhysicalGpuHandle handle)
{
string gpuName;
if (NVAPI.NvAPI_GPU_GetFullName(handle, out gpuName) == NvStatus.OK)
{
return(gpuName.Trim());
}
else
{
return("NVIDIA");
}
}
static NvGPUThermalSettings GetThermalSettings(NvPhysicalGpuHandle handle)
{
NvGPUThermalSettings settings = new NvGPUThermalSettings();
settings.Version = NVAPI.GPU_THERMAL_SETTINGS_VER;
settings.Count = NVAPI.MAX_THERMAL_SENSORS_PER_GPU;
settings.Sensor = new NvSensor[NVAPI.MAX_THERMAL_SENSORS_PER_GPU];
if (NVAPI.NvAPI_GPU_GetThermalSettings(handle, (int)NvThermalTarget.ALL,
ref settings) != NvStatus.OK)
{
settings.Count = 0;
}
return(settings);
}
private NvPhysicalGpuHandle?GetNvPhysicalGpuHandle()
{
if (_NvPhysicalGpuHandle.HasValue)
{
return(_NvPhysicalGpuHandle.Value);
}
if (NVAPI.NvAPI_EnumPhysicalGPUs == null)
{
Logger.DebugDelayed("NVAPI", "NvAPI_EnumPhysicalGPUs unavailable", TimeSpan.FromMinutes(5));
return(null);
}
if (NVAPI.NvAPI_GPU_GetBusID == null)
{
Logger.DebugDelayed("NVAPI", "NvAPI_GPU_GetBusID unavailable", TimeSpan.FromMinutes(5));
return(null);
}
var handles = new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
var status = NVAPI.NvAPI_EnumPhysicalGPUs(handles, out _);
if (status != NvStatus.OK)
{
Logger.DebugDelayed("NVAPI", $"Enum physical GPUs failed with status: {status}", TimeSpan.FromMinutes(5));
}
else
{
foreach (var handle in handles)
{
var idStatus = NVAPI.NvAPI_GPU_GetBusID(handle, out var id);
if (idStatus == NvStatus.EXPECTED_PHYSICAL_GPU_HANDLE)
{
continue;
}
if (idStatus != NvStatus.OK)
{
Logger.DebugDelayed("NVAPI", "Bus ID get failed with status: " + idStatus, TimeSpan.FromMinutes(5));
}
else if (id == BusID)
{
Logger.DebugDelayed("NVAPI", "Found handle for busid " + id, TimeSpan.FromMinutes(5));
_NvPhysicalGpuHandle = handle;
return(handle);
}
}
}
return(null);
}
private static Dictionary <int, NvPhysicalGpuHandle> InitNvapi()
{
var idHandles = new Dictionary <int, NvPhysicalGpuHandle>();
if (!NVAPI.IsAvailable)
{
return(idHandles);
}
var handles = new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
if (NVAPI.NvAPI_EnumPhysicalGPUs == null)
{
Logger.Debug("NVAPI", "NvAPI_EnumPhysicalGPUs unavailable");
}
else
{
var status = NVAPI.NvAPI_EnumPhysicalGPUs(handles, out _);
if (status != NvStatus.OK)
{
Logger.Debug("NVAPI", $"Enum physical GPUs failed with status: {status}");
}
else
{
foreach (var handle in handles)
{
var idStatus = NVAPI.NvAPI_GPU_GetBusID(handle, out var id);
if (idStatus == NvStatus.EXPECTED_PHYSICAL_GPU_HANDLE)
{
continue;
}
if (idStatus != NvStatus.OK)
{
Logger.Debug("NVAPI",
"Bus ID get failed with status: " + idStatus);
}
else
{
Logger.Debug("NVAPI", "Found handle for busid " + id);
idHandles[id] = handle;
}
}
}
}
return(idHandles);
}
public NvidiaModelAccessor()
{
//This constructor itterates through each of GPU's and generates a NvidiaGpuModel Object for each of them appending.
int count;
IDictionary <NvPhysicalGpuHandle, NvDisplayHandle> displayHandles = new Dictionary <NvPhysicalGpuHandle, NvDisplayHandle>();
NvPhysicalGpuHandle[] handles = new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
NvStatus status = NVAPI.NvAPI_EnumPhysicalGPUs(handles, out count);
for (int i = 0; i < count; i++)
{
NvDisplayHandle displayHandle;
displayHandles.TryGetValue(handles[i], out displayHandle);
_gpuList.Add(new NvidiaGpuModel(i, handles[i], displayHandle));
}
}
private NvPhysicalGpuHandle FindPhysicalGpuHandleForBus(uint bus)
{
NvPhysicalGpuHandle[] handlesFromDisplay =
new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
if (NVAPI.NvAPI_EnumPhysicalGPUs(handlesFromDisplay, out int count) == NvStatus.OK)
{
foreach (NvPhysicalGpuHandle physHandle in handlesFromDisplay)
{
if (NVAPI.NvAPI_GPU_GetBusID(physHandle, out int physBus) == NvStatus.OK && physBus == bus)
{
return(physHandle);
}
}
}
return(new NvPhysicalGpuHandle());
}
public CudaComputeDevice(CudaDevice cudaDevice, DeviceGroupType group, int GPUCount, NvPhysicalGpuHandle nvHandle)
: base((int)cudaDevice.DeviceID,
cudaDevice.GetName(),
true,
group,
cudaDevice.IsEtherumCapable(),
DeviceType.NVIDIA,
String.Format(International.GetText("ComputeDevice_Short_Name_NVIDIA_GPU"), GPUCount),
cudaDevice.DeviceGlobalMemory)
{
_SM_major = cudaDevice.SM_major;
_SM_minor = cudaDevice.SM_minor;
UUID = cudaDevice.UUID;
AlgorithmSettings = GroupAlgorithms.CreateForDeviceList(this);
Index = ID + ComputeDeviceManager.Avaliable.AvailCPUs; // increment by CPU count
this.nvHandle = nvHandle;
}
public static NvStatus NvApiGpuGetFullName(NvPhysicalGpuHandle handle, out string name)
{
if (GpuGetFullName == null)
{
name = "Unknown";
return(NvStatus.FunctionNotFound);
}
try {
var builder = new StringBuilder(short.MaxValue);
var status = GpuGetFullName(handle, builder);
name = builder.ToString();
return(status);
} catch (AccessViolationException ave) {
Logger.Error($"Unable to get GPU name from handle {handle}", ave);
name = "Unknown";
return(NvStatus.FunctionNotFound);
}
}
public float GetSensorValue(int deviceIndex, SensorType sensorType)
{
NvPhysicalGpuHandle physicalHandle = nvPhysicalGpuHandles[deviceIndex];
switch (sensorType)
{
case SensorType.GFX_LOAD:
if (NvAPI_GPU_GetDynamicPstatesInfoEx != null)
{
NvDynamicPstatesInfoEx infoEx = new NvDynamicPstatesInfoEx();
infoEx.Version = GPU_DYNAMIC_PSTATES_INFO_EX_VER;
infoEx.UtilizationDomains = new NvUtilizationDomainEx[NVAPI_MAX_GPU_UTILIZATIONS];
return(NvAPI_GPU_GetDynamicPstatesInfoEx(physicalHandle, ref infoEx) == 0 && infoEx.UtilizationDomains[0].Present ? infoEx.UtilizationDomains[0].Percentage / 100.0f : 0);
}
if (NvAPI_GPU_GetDynamicPstatesInfo != null)
{
NvDynamicPstatesInfo info = new NvDynamicPstatesInfo();
info.Version = GPU_DYNAMIC_PSTATES_INFO_VER;
info.UtilizationDomains = new NvUtilizationDomain[NVAPI_MAX_GPU_UTILIZATIONS];
return(NvAPI_GPU_GetDynamicPstatesInfo(physicalHandle, ref info) == 0 && info.UtilizationDomains[0].Present ? info.UtilizationDomains[0].Percentage : 0);
}
break;
case SensorType.GFX_TEMPERATURE:
if (NvAPI_GPU_GetThermalSettings != null)
{
NvGPUThermalSettings thermalSettings = new NvGPUThermalSettings();
thermalSettings.Version = GPU_THERMAL_SETTINGS_VER;
thermalSettings.Count = MAX_THERMAL_SENSORS_PER_GPU;
thermalSettings.Sensor = new NvSensor[MAX_THERMAL_SENSORS_PER_GPU];
return(NvAPI_GPU_GetThermalSettings(physicalHandle, (int)NvThermalTarget.ALL, ref thermalSettings) == 0 ?
Array.Find(thermalSettings.Sensor, sensor => sensor.Target == NvThermalTarget.GPU).CurrentTemp : 0);
}
break;
case SensorType.GFX_POWER:
break;
}
return(0);
}
public NVidiaGpu(int adapterIndex, NvPhysicalGpuHandle handle)
{
AdapterHandle = handle;
_gpuIdentifer = new NVidiaGpuIdentifer(this);
GpuModelName = NvApi.NvApiGpuGetFullName(handle, out var gpuName) == NvStatus.Ok ? gpuName.Trim() : "Unknown";
if (NvApi.GetPciIdentifiers != null && NvApi.GetPciIdentifiers(AdapterHandle, out var deviceId, out var subSystemId, out var revisionId, out var extDeviceId) == NvStatus.Ok)
{
DeviceId = $"0x{deviceId:X}";
SubSystemId = $"0x{subSystemId:X}";
RevisionId = $"0x{revisionId:X}";
}
if (NvApi.GetBusSlotId != null && NvApi.GetBusId(AdapterHandle, out _busId) != NvStatus.Ok)
{
throw new Exception("Unable to obtain bus slot id");
}
GpuFullName = $"NVIDIA {GpuModelName}";
}
public CudaComputeDevice(CudaDevice cudaDevice, DeviceGroupType group, int gpuCount,
NvPhysicalGpuHandle nvHandle, nvmlDevice nvmlHandle)
: base((int)cudaDevice.DeviceID,
cudaDevice.GetName(),
true,
group,
cudaDevice.IsEtherumCapable(),
DeviceType.NVIDIA,
string.Format(International.GetText("ComputeDevice_Short_Name_NVIDIA_GPU"), gpuCount),
cudaDevice.DeviceGlobalMemory)
{
BusID = cudaDevice.pciBusID;
SMMajor = cudaDevice.SM_major;
SMMinor = cudaDevice.SM_minor;
UUID = cudaDevice.UUID;
AlgorithmSettings = GroupAlgorithms.CreateForDeviceList(this);
Index = ID + ComputeDeviceManager.Avaliable.AvailCPUs; // increment by CPU count
_nvHandle = nvHandle;
nvmlDevice = nvmlHandle;
ShouldRunEthlargement = cudaDevice.DeviceName.Contains("1080") || cudaDevice.DeviceName.Contains("Titan Xp");
}
public CudaComputeDevice(CudaDevice cudaDevice, DeviceGroupType group, int gpuCount,
NvPhysicalGpuHandle nvHandle, nvmlDevice nvmlHandle)
: base((int)cudaDevice.DeviceID,
cudaDevice.GetName(),
true,
group,
cudaDevice.IsEtherumCapable(),
DeviceType.NVIDIA,
string.Format(Translations.Tr("GPU#{0}"), gpuCount),
cudaDevice.DeviceGlobalMemory)
{
BusID = cudaDevice.pciBusID;
SMMajor = cudaDevice.SM_major;
SMMinor = cudaDevice.SM_minor;
Uuid = cudaDevice.UUID;
AlgorithmSettings = GroupAlgorithms.CreateForDeviceList(this);
Index = ID + AvailableDevices.AvailCpus; // increment by CPU count
_nvHandle = nvHandle;
_nvmlDevice = nvmlHandle;
ShouldRunEthlargement = cudaDevice.DeviceName.Contains("1080") || cudaDevice.DeviceName.Contains("Titan Xp");
}
public void ResetHandles(NvapiNvmlInfo info)
{
_nvHandle = info.nvHandle;
_nvmlDevice = info.nvmlHandle;
try
{
var powerInfo = new NvGPUPowerInfo
{
Version = NVAPI.GPU_POWER_INFO_VER,
Entries = new NvGPUPowerInfoEntry[4]
};
var ret = NVAPI.NvAPI_DLL_ClientPowerPoliciesGetInfo(_nvHandle, ref powerInfo);
if (ret != NvStatus.OK)
{
throw new Exception(ret.ToString());
}
Debug.Assert(powerInfo.Entries.Length == 4);
if (powerInfo.Entries[0].MinPower == 0 || powerInfo.Entries[0].MaxPower == 0)
{
throw new Exception("Power control not available!");
}
_minPowerLimit = powerInfo.Entries[0].MinPower;
_maxPowerLimit = powerInfo.Entries[0].MaxPower;
_defaultPowerLimit = powerInfo.Entries[0].DefPower;
}
catch (Exception e)
{
Logger.Error("NVML", $"Getting power info failed with message \"{e.Message}\", disabling power setting");
PowerLimitsEnabled = false;
}
}
public static void QueryCudaDevices()
{
Helpers.ConsolePrint(Tag, "QueryCudaDevices START");
QueryCudaDevices(ref _cudaDevices);
if (_cudaDevices != null && _cudaDevices.Count != 0)
{
Available.HasNvidia = true;
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine("");
stringBuilder.AppendLine("CudaDevicesDetection:");
// Enumerate NVAPI handles and map to busid
var idHandles = new Dictionary <int, NvPhysicalGpuHandle>();
if (NVAPI.IsAvailable)
{
var handles = new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
if (NVAPI.NvAPI_EnumPhysicalGPUs == null)
{
Helpers.ConsolePrint("NVAPI", "NvAPI_EnumPhysicalGPUs unavailable");
}
else
{
var status = NVAPI.NvAPI_EnumPhysicalGPUs(handles, out var _);
if (status != NvStatus.OK)
{
Helpers.ConsolePrint("NVAPI", "Enum physical GPUs failed with status: " + status);
}
else
{
foreach (var handle in handles)
{
var idStatus = NVAPI.NvAPI_GPU_GetBusID(handle, out var id);
if (idStatus != NvStatus.EXPECTED_PHYSICAL_GPU_HANDLE)
{
if (idStatus != NvStatus.OK)
{
Helpers.ConsolePrint("NVAPI",
"Bus ID get failed with status: " + idStatus);
}
else
{
Helpers.ConsolePrint("NVAPI", "Found handle for busid " + id);
idHandles[id] = handle;
}
}
}
}
}
}
var nvmlInit = false;
try
{
var ret = NvmlNativeMethods.nvmlInit();
if (ret != nvmlReturn.Success)
{
throw new Exception($"NVML init failed with code {ret}");
}
nvmlInit = true;
}
catch (Exception e)
{
Helpers.ConsolePrint("NVML", e.ToString());
}
foreach (var cudaDev in _cudaDevices)
{
// check sm vesrions
bool isUnderSM21;
{
var isUnderSM2Major = cudaDev.SM_major < 2;
var isUnderSM1Minor = cudaDev.SM_minor < 1;
isUnderSM21 = isUnderSM2Major && isUnderSM1Minor;
}
//bool isOverSM6 = cudaDev.SM_major > 6;
var skip = isUnderSM21;
var skipOrAdd = skip ? "SKIPED" : "ADDED";
const string isDisabledGroupStr = ""; // TODO remove
var etherumCapableStr = cudaDev.IsEtherumCapable() ? "YES" : "NO";
stringBuilder.AppendLine($"\t{skipOrAdd} device{isDisabledGroupStr}:");
stringBuilder.AppendLine($"\t\tID: {cudaDev.DeviceID}");
stringBuilder.AppendLine($"\t\tBusID: {cudaDev.pciBusID}");
stringBuilder.AppendLine($"\t\tNAME: {cudaDev.GetName()}");
stringBuilder.AppendLine($"\t\tVENDOR: {cudaDev.VendorName}");
stringBuilder.AppendLine($"\t\tUUID: {cudaDev.UUID}");
stringBuilder.AppendLine($"\t\tSM: {cudaDev.SMVersionString}");
stringBuilder.AppendLine($"\t\tMEMORY: {cudaDev.DeviceGlobalMemory}");
stringBuilder.AppendLine($"\t\tETHEREUM: {etherumCapableStr}");
if (!skip)
{
DeviceGroupType group;
switch (cudaDev.SM_major)
{
case 2:
group = DeviceGroupType.NVIDIA_2_1;
break;
case 3:
group = DeviceGroupType.NVIDIA_3_x;
break;
case 5:
group = DeviceGroupType.NVIDIA_5_x;
break;
case 6:
group = DeviceGroupType.NVIDIA_6_x;
break;
default:
group = DeviceGroupType.NVIDIA_6_x;
break;
}
var nvmlHandle = new nvmlDevice();
if (nvmlInit)
{
var ret = NvmlNativeMethods.nvmlDeviceGetHandleByUUID(cudaDev.UUID, ref nvmlHandle);
stringBuilder.AppendLine(
"\t\tNVML HANDLE: " +
$"{(ret == nvmlReturn.Success ? nvmlHandle.Pointer.ToString() : $"Failed with code ret {ret}")}");
}
idHandles.TryGetValue(cudaDev.pciBusID, out var handle);
Available.Devices.Add(
new CudaComputeDevice(cudaDev, group, ++GpuCount, handle, nvmlHandle)
);
}
}
Helpers.ConsolePrint(Tag, stringBuilder.ToString());
}
public Nvidia()
{
bool available = NVAPI.IsAvailable;
NvPhysicalGpuHandle[] handles = new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
int count;
if (NVAPI.NvAPI_EnumPhysicalGPUs == null)
{
//Console.WriteLine("Error: NvAPI_EnumPhysicalGPUs not available");
return;
}
else
{
NvStatus status = NVAPI.NvAPI_EnumPhysicalGPUs(handles, out count);
if (status != NvStatus.OK)
{
//Console.WriteLine("Error: NvAPI_EnumPhysicalGPUs not available");
//Console.WriteLine("Status: " + status);
return;
}
}
IDictionary <NvPhysicalGpuHandle, NvDisplayHandle> displayHandles = new Dictionary <NvPhysicalGpuHandle, NvDisplayHandle>();
NvDisplayHandle displayHandle;
if (NVAPI.NvAPI_EnumNvidiaDisplayHandle != null && NVAPI.NvAPI_GetPhysicalGPUsFromDisplay != null)
{
NvStatus status = NvStatus.OK;
int i = 0;
while (status == NvStatus.OK)
{
displayHandle = new NvDisplayHandle();
status = NVAPI.NvAPI_EnumNvidiaDisplayHandle(i, ref displayHandle);
i++;
if (status == NvStatus.OK)
{
NvPhysicalGpuHandle[] handlesFromDisplay = new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
uint countFromDisplay;
if (NVAPI.NvAPI_GetPhysicalGPUsFromDisplay(displayHandle, handlesFromDisplay, out countFromDisplay) == NvStatus.OK)
{
for (int j = 0; j < countFromDisplay; j++)
{
if (!displayHandles.ContainsKey(handlesFromDisplay[j]))
{
displayHandles.Add(handlesFromDisplay[j], displayHandle);
}
}
}
}
}
}
if (count > 1)
{
Console.WriteLine("only suppoert 1 GUP");
}
displayHandles.TryGetValue(handles[0], out displayHandle);
this._handle = handles[0];
this._displayHandle = displayHandle;
this.Name = GetName(this._handle);
}
public NvidiaGPU(int adapterIndex, NvPhysicalGpuHandle handle,
NvDisplayHandle? displayHandle, ISettings settings)
: base(GetName(handle), new Identifier("nvidiagpu",
adapterIndex.ToString(CultureInfo.InvariantCulture)), settings)
{
this.adapterIndex = adapterIndex;
this.handle = handle;
this.displayHandle = displayHandle;
NvGPUThermalSettings thermalSettings = GetThermalSettings();
temperatures = new Sensor[thermalSettings.Count];
for (int i = 0; i < temperatures.Length; i++) {
NvSensor sensor = thermalSettings.Sensor[i];
string name;
switch (sensor.Target) {
case NvThermalTarget.BOARD: name = "GPU Board"; break;
case NvThermalTarget.GPU: name = "GPU Core"; break;
case NvThermalTarget.MEMORY: name = "GPU Memory"; break;
case NvThermalTarget.POWER_SUPPLY: name = "GPU Power Supply"; break;
case NvThermalTarget.UNKNOWN: name = "GPU Unknown"; break;
default: name = "GPU"; break;
}
temperatures[i] = new Sensor(name, i, SensorType.Temperature, this,
new ParameterDescription[0], settings);
ActivateSensor(temperatures[i]);
}
int value;
if (NVAPI.NvAPI_GPU_GetTachReading != null &&
NVAPI.NvAPI_GPU_GetTachReading(handle, out value) == NvStatus.OK) {
if (value >= 0) {
fan = new Sensor("GPU", 0, SensorType.Fan, this, settings);
ActivateSensor(fan);
}
}
clocks = new Sensor[3];
clocks[0] = new Sensor("GPU Core", 0, SensorType.Clock, this, settings);
clocks[1] = new Sensor("GPU Memory", 1, SensorType.Clock, this, settings);
clocks[2] = new Sensor("GPU Shader", 2, SensorType.Clock, this, settings);
for (int i = 0; i < clocks.Length; i++)
ActivateSensor(clocks[i]);
loads = new Sensor[3];
loads[0] = new Sensor("GPU Core", 0, SensorType.Load, this, settings);
loads[1] = new Sensor("GPU Memory Controller", 1, SensorType.Load, this, settings);
loads[2] = new Sensor("GPU Video Engine", 2, SensorType.Load, this, settings);
memoryLoad = new Sensor("GPU Memory", 3, SensorType.Load, this, settings);
memoryFree = new Sensor("GPU Memory Free", 1, SensorType.SmallData, this, settings);
memoryUsed = new Sensor("GPU Memory Used", 2, SensorType.SmallData, this, settings);
memoryAvail = new Sensor("GPU Memory Total", 3, SensorType.SmallData, this, settings);
control = new Sensor("GPU Fan", 0, SensorType.Control, this, settings);
NvGPUCoolerSettings coolerSettings = GetCoolerSettings();
if (coolerSettings.Count > 0) {
fanControl = new Control(control, settings,
coolerSettings.Cooler[0].DefaultMin,
coolerSettings.Cooler[0].DefaultMax);
fanControl.ControlModeChanged += ControlModeChanged;
fanControl.SoftwareControlValueChanged += SoftwareControlValueChanged;
ControlModeChanged(fanControl);
control.Control = fanControl;
}
Update();
}
private static string GetName(NvPhysicalGpuHandle handle)
{
string gpuName;
if (NVAPI.NvAPI_GPU_GetFullName(handle, out gpuName) == NvStatus.OK) {
return "NVIDIA " + gpuName.Trim();
} else {
return "NVIDIA";
}
}
public GpuSensor()
{
if (!NVAPI.IsAvailable)
{
throw new Exception("Unable to obtain primary GPU; NVAPI is not available");
}
NvPhysicalGpuHandle[] handles = new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
int numGpus;
if (NVAPI.NvAPI_EnumPhysicalGPUs == null)
{
throw new Exception("Unable to obtain primary GPU; NvAPI_EnumPhysicalGPUs not available");
}
else
{
NvStatus status = NVAPI.NvAPI_EnumPhysicalGPUs(handles, out numGpus);
if (status != NvStatus.OK)
{
throw new Exception("Unable to obtain primary GPU");
}
}
if (numGpus < 1)
{
throw new Exception("Unable to obtain primary GPU");
}
gpuHandle = handles[0];
IDictionary <NvPhysicalGpuHandle, NvDisplayHandle> displayHandles = new Dictionary <NvPhysicalGpuHandle, NvDisplayHandle>();
if (NVAPI.NvAPI_EnumNvidiaDisplayHandle != null && NVAPI.NvAPI_GetPhysicalGPUsFromDisplay != null)
{
int i = 0;
NvStatus status = NvStatus.OK;
while (status == NvStatus.OK)
{
NvDisplayHandle displayHandle = new NvDisplayHandle();
status = NVAPI.NvAPI_EnumNvidiaDisplayHandle(i, ref displayHandle);
i++;
if (status == NvStatus.OK)
{
NvPhysicalGpuHandle[] handlesFromDisplay = new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
if (NVAPI.NvAPI_GetPhysicalGPUsFromDisplay(displayHandle, handlesFromDisplay, out uint countFromDisplay) == NvStatus.OK)
{
for (int j = 0; j < countFromDisplay; j++)
{
if (!displayHandles.ContainsKey(handlesFromDisplay[j]))
{
displayHandles.Add(handlesFromDisplay[j], displayHandle);
}
}
}
}
}
}
displayHandles.TryGetValue(handles[0], out displayHandle);
}
public NvidiaGroup(ISettings settings)
{
if (!NVAPI.IsAvailable)
return;
report.AppendLine("NVAPI");
report.AppendLine();
string version;
if (NVAPI.NvAPI_GetInterfaceVersionString(out version) == NvStatus.OK) {
report.Append("Version: ");
report.AppendLine(version);
}
NvPhysicalGpuHandle[] handles =
new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
int count;
if (NVAPI.NvAPI_EnumPhysicalGPUs == null) {
report.AppendLine("Error: NvAPI_EnumPhysicalGPUs not available");
report.AppendLine();
return;
} else {
NvStatus status = NVAPI.NvAPI_EnumPhysicalGPUs(handles, out count);
if (status != NvStatus.OK) {
report.AppendLine("Status: " + status);
report.AppendLine();
return;
}
}
IDictionary<NvPhysicalGpuHandle, NvDisplayHandle> displayHandles =
new Dictionary<NvPhysicalGpuHandle, NvDisplayHandle>();
if (NVAPI.NvAPI_EnumNvidiaDisplayHandle != null &&
NVAPI.NvAPI_GetPhysicalGPUsFromDisplay != null)
{
NvStatus status = NvStatus.OK;
int i = 0;
while (status == NvStatus.OK) {
NvDisplayHandle displayHandle = new NvDisplayHandle();
status = NVAPI.NvAPI_EnumNvidiaDisplayHandle(i, ref displayHandle);
i++;
if (status == NvStatus.OK) {
NvPhysicalGpuHandle[] handlesFromDisplay =
new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
uint countFromDisplay;
if (NVAPI.NvAPI_GetPhysicalGPUsFromDisplay(displayHandle,
handlesFromDisplay, out countFromDisplay) == NvStatus.OK) {
for (int j = 0; j < countFromDisplay; j++) {
if (!displayHandles.ContainsKey(handlesFromDisplay[j]))
displayHandles.Add(handlesFromDisplay[j], displayHandle);
}
}
}
}
}
report.Append("Number of GPUs: ");
report.AppendLine(count.ToString(CultureInfo.InvariantCulture));
for (int i = 0; i < count; i++) {
NvDisplayHandle displayHandle;
displayHandles.TryGetValue(handles[i], out displayHandle);
hardware.Add(new NvidiaGPU(i, handles[i], displayHandle, settings));
}
report.AppendLine();
}
static NvGPUThermalSettings GetThermalSettings(NvPhysicalGpuHandle handle)
{
NvGPUThermalSettings settings = new NvGPUThermalSettings();
settings.Version = NVAPI.GPU_THERMAL_SETTINGS_VER;
settings.Count = NVAPI.MAX_THERMAL_SENSORS_PER_GPU;
settings.Sensor = new NvSensor[NVAPI.MAX_THERMAL_SENSORS_PER_GPU];
if (NVAPI.NvAPI_GPU_GetThermalSettings(handle, (int)NvThermalTarget.ALL,
ref settings) != NvStatus.OK)
{
settings.Count = 0;
}
return settings;
}
