/// <summary>
/// Provides access to <see cref="UnitGetLedState_Interop"/>
/// without using raw pointers.
/// </summary>
public unsafe NvmlReturn UnitGetLedState(IntPtr unit, out NvmlLedState ledState)
{
NvmlReturn result = UnitGetLedState_Interop(unit, out var interopResult);
if (result == NvmlReturn.NVML_SUCCESS)
{
var causeSpan = new Span <byte>(
interopResult.Cause,
NvmlLedState_Interop.NVML_MAX_CAUSE);
var strlen = causeSpan.IndexOf <byte>(0);
var cause = Encoding.UTF8.GetString(interopResult.Cause, strlen);
ledState =
new NvmlLedState()
{
Cause = cause,
Color = interopResult.Color,
};
}
else
{
ledState = default;
}
return(result);
}
/// <summary>
/// Helper method to read an array of values from the NVML Interop API.
/// </summary>
/// <param name="interopFunc">The interop function.</param>
/// <param name="nvmlArray">Filled in with the result array.</param>
/// <returns>The interop status code.</returns>
internal unsafe static NvmlReturn GetNvmlArray <T>(
GetNvmlArrayInterop <T> interopFunc,
out T[] nvmlArray)
where T : unmanaged
{
// Query the length of data available.
// If the result is success, that means an empty array.
uint length = 0;
NvmlReturn result = interopFunc(ref length, null);
if (result == NvmlReturn.NVML_SUCCESS)
{
nvmlArray = Array.Empty <T>();
return(result);
}
else if (result == NvmlReturn.NVML_ERROR_INSUFFICIENT_SIZE)
{
// Allocate the correct size, and call the interop again.
T[] buffer = new T[length];
fixed(T *ptr = buffer)
{
result = interopFunc(ref length, ptr);
nvmlArray = result == NvmlReturn.NVML_SUCCESS
? buffer
: default;
return(result);
}
}
else
{
nvmlArray = default;
return(result);
}
}
public static void ThrowIfFailed(NvmlReturn errorCode)
{
if (errorCode != NvmlReturn.NVML_SUCCESS)
{
throw new NvmlException(errorCode);
}
}
/// <summary>
/// Provides access to <see cref="UnitGetPsuInfo_Interop"/>
/// without using raw pointers.
/// </summary>
public unsafe NvmlReturn UnitGetPsuInfo(IntPtr unit, out NvmlPSUInfo psuInfo)
{
NvmlReturn result = UnitGetPsuInfo_Interop(unit, out var interopResult);
if (result == NvmlReturn.NVML_SUCCESS)
{
var stateSpan = new Span <byte>(
interopResult.State,
NvmlPSUInfo_Interop.NVML_MAX_STATE);
var strlen = stateSpan.IndexOf <byte>(0);
var state = Encoding.UTF8.GetString(interopResult.State, strlen);
psuInfo =
new NvmlPSUInfo()
{
Current = interopResult.Current,
Power = interopResult.Power,
State = state,
Voltage = interopResult.Voltage,
};
}
else
{
psuInfo = default;
}
return(result);
}
public static NvmlReturn GetDriverVersionString(out string version)
{
StringBuilder builder = new StringBuilder(SYSTEM_DRIVER_VERSION_BUFFER_SIZE);
NvmlReturn result = NvmlSystemGetDriverVersion(builder, SYSTEM_DRIVER_VERSION_BUFFER_SIZE);
version = builder.ToString();
return(result);
}
public static NvmlReturn GetDeviceVbiosVersionString(NvmlDevice device, out string version)
{
StringBuilder builder = new StringBuilder(DEVICE_VBIOS_VERSION_BUFFER_SIZE);
NvmlReturn result = NvmlDeviceGetVbiosVersion(device, builder, DEVICE_VBIOS_VERSION_BUFFER_SIZE);
version = builder.ToString();
return(result);
}
public static NvmlReturn GetDeviceUUID(NvmlDevice device, out string uuid)
{
StringBuilder builder = new StringBuilder(DEVICE_UUID_BUFFER_SIZE);
NvmlReturn result = NvmlDeviceGetUUID(device, builder, DEVICE_UUID_BUFFER_SIZE);
uuid = builder.ToString();
return(result);
}
public static NvmlReturn GetDeviceName(NvmlDevice device, out string name)
{
StringBuilder builder = new StringBuilder(DEVICE_NAME_BUFFER_SIZE);
NvmlReturn result = NvmlDeviceGetName(device, builder, DEVICE_NAME_BUFFER_SIZE);
name = builder.ToString();
return(result);
}
/// <summary>
/// Provides access to <see cref="SystemGetCudaDriverVersion_v2_Interop"/>
/// without using raw pointers.
/// </summary>
public NvmlReturn SystemGetCudaDriverVersion_v2(
out CudaDriverVersion cudaDriverVersion)
{
NvmlReturn result = SystemGetCudaDriverVersion_v2_Interop(out int version);
cudaDriverVersion = result == NvmlReturn.NVML_SUCCESS
? CudaDriverVersion.FromValue(version)
: default;
return(result);
}
/// <summary>
/// Provides access to <see cref="UnitGetUnitInfo_Interop"/>
/// without using raw pointers.
/// </summary>
public unsafe NvmlReturn UnitGetUnitInfo(IntPtr unit, out NvmlUnitInfo info)
{
NvmlReturn result = UnitGetUnitInfo_Interop(unit, out var interopResult);
if (result == NvmlReturn.NVML_SUCCESS)
{
var strSpan = new Span <byte>(
interopResult.FirmwareVersion,
NvmlUnitInfo_Interop.NVML_MAX_STRLEN);
var strlen = strSpan.IndexOf <byte>(0);
string firmwareVersion = Encoding.UTF8.GetString(
interopResult.FirmwareVersion,
strlen);
strSpan = new Span <byte>(
interopResult.Id,
NvmlUnitInfo_Interop.NVML_MAX_STRLEN);
strlen = strSpan.IndexOf <byte>(0);
string id = Encoding.UTF8.GetString(
interopResult.Id,
strlen);
strSpan = new Span <byte>(
interopResult.Name,
NvmlUnitInfo_Interop.NVML_MAX_STRLEN);
strlen = strSpan.IndexOf <byte>(0);
string name = Encoding.UTF8.GetString(
interopResult.Name,
strlen);
strSpan = new Span <byte>(
interopResult.Serial,
NvmlUnitInfo_Interop.NVML_MAX_STRLEN);
strlen = strSpan.IndexOf <byte>(0);
string serial = Encoding.UTF8.GetString(
interopResult.Serial,
strlen);
info =
new NvmlUnitInfo()
{
FirmwareVersion = firmwareVersion,
Id = id,
Name = name,
Serial = serial,
};
}
else
{
info = default;
}
return(result);
}
public static uint NvmlDeviceGetCountV2()
{
uint count = 0;
NvmlReturn res = Api.NvmlDeviceGetCount_v2(out count);
if (NvmlReturn.NVML_SUCCESS != res)
{
throw new SystemException(res.ToString());
}
return(count);
}
public static NvmlPciInfo NvmlDeviceGetPciInfoV3(IntPtr device)
{
NvmlPciInfo data = new NvmlPciInfo();
NvmlReturn res = Api.NvmlDeviceGetPciInfo_v3(device, out data);
if (NvmlReturn.NVML_SUCCESS != res)
{
throw new SystemException(res.ToString());
}
return(data);
}
public static string NvmlDeviceGetBoardPartNumber(IntPtr device, uint length)
{
byte[] partNumber = new byte[length];
NvmlReturn res = Api.NvmlDeviceGetBoardPartNumber(device, partNumber, length);
if (NvmlReturn.NVML_SUCCESS != res)
{
throw new SystemException(res.ToString());
}
return(Encoding.Default.GetString(partNumber).Replace("\0", ""));
}
/// <summary>
/// Helper method to read an array of values from the NVML Interop API.
/// </summary>
/// <param name="interopFunc">The interop function.</param>
/// <param name="nvmlArray1">Filled in with the result array.</param>
/// <param name="nvmlArray2">Filled in with the result array.</param>
/// <returns>The interop status code.</returns>
internal unsafe static NvmlReturn GetNvmlArray <T1, T2>(
GetNvmlArrayInterop <T1, T2> interopFunc,
out T1[] nvmlArray1,
out T2[] nvmlArray2)
where T1 : unmanaged
where T2 : unmanaged
{
// Query the length of data available.
// If the result is success, that means an empty array.
uint length = 0;
NvmlReturn result = interopFunc(ref length, null, null);
if (result == NvmlReturn.NVML_SUCCESS)
{
nvmlArray1 = Array.Empty <T1>();
nvmlArray2 = Array.Empty <T2>();
return(result);
}
else if (result == NvmlReturn.NVML_ERROR_INSUFFICIENT_SIZE)
{
// Allocate the correct size, and call the interop again.
T1[] buffer1 = new T1[length];
T2[] buffer2 = new T2[length];
fixed(T1 *ptr1 = buffer1)
fixed(T2 * ptr2 = buffer2)
{
result = interopFunc(ref length, ptr1, ptr2);
if (result == NvmlReturn.NVML_SUCCESS)
{
nvmlArray1 = buffer1;
nvmlArray2 = buffer2;
}
else
{
nvmlArray1 = default;
nvmlArray2 = default;
}
return(result);
}
}
else
{
nvmlArray1 = default;
nvmlArray2 = default;
return(result);
}
}
/// <summary>
/// Helper method to fill a fixed sized array of values from the NVML Interop API.
/// </summary>
/// <param name="interopFunc">The interop function.</param>
/// <param name="length">The desired length.</param>
/// <param name="nvmlArray">Filled in with the result array.</param>
/// <returns>The interop status code.</returns>
internal unsafe static NvmlReturn FillNvmlArray <T>(
FillNvmlArrayInterop <T> interopFunc,
uint length,
out T[] nvmlArray)
where T : unmanaged
{
// Allocate enough space for the requested length.
T[] buffer = new T[length];
fixed(T *ptr = buffer)
{
NvmlReturn result = interopFunc(length, ptr);
nvmlArray = (result == NvmlReturn.NVML_SUCCESS) ? buffer : default;
return(result);
}
}
/// <summary>
/// Provides access to <see cref="DeviceGetSamples_Interop"/>
/// without using raw pointers.
/// </summary>
public unsafe NvmlReturn DeviceGetSamples(
IntPtr device,
NvmlSamplingType type,
ulong lastSeenTimeStamp,
out NvmlValueType sampleValType,
uint sampleCount,
out NvmlSample[] samples)
{
// Allocate enough space for sampleCount.
uint length = sampleCount;
NvmlSample[] buffer = new NvmlSample[length];
fixed(NvmlSample *ptr = buffer)
{
NvmlReturn result = DeviceGetSamples_Interop(
device,
type,
lastSeenTimeStamp,
out sampleValType,
ref length,
ptr);
if (result == NvmlReturn.NVML_SUCCESS)
{
// Adjust the return buffer to the actual length.
if (length < sampleCount)
{
Array.Resize(ref buffer, (int)length);
}
samples = buffer;
}
else
{
samples = default;
}
return(result);
}
}
/// <summary>
/// Provides access to <see cref="SystemGetHicVersion_Interop"/>
/// without using raw pointers.
/// </summary>
public unsafe NvmlReturn SystemGetHicVersion(out NvmlHwbcEntry[] hwbcEntries)
{
NvmlReturn Interop(ref uint len, NvmlHwbcEntry_Interop *ptr) =>
SystemGetHicVersion_Interop(ref len, ptr);
NvmlReturn result = GetNvmlArray <NvmlHwbcEntry_Interop>(
Interop,
out var interopResult);
if (result == NvmlReturn.NVML_SUCCESS)
{
hwbcEntries = new NvmlHwbcEntry[interopResult.Length];
for (int i = 0; i < interopResult.Length; i++)
{
var interopItem = interopResult[i];
var firmwareVersionSpan = new Span <byte>(
interopItem.FirmwareVersion,
NvmlHwbcEntry_Interop.NVML_MAX_FIRMWAREVERSION);
var strlen = firmwareVersionSpan.IndexOf <byte>(0);
var firmwareVersion = Encoding.UTF8.GetString(
interopItem.FirmwareVersion,
strlen);
hwbcEntries[i] =
new NvmlHwbcEntry
{
HwbcId = interopResult[i].HwbcId,
FirmwareVersion = firmwareVersion,
};
}
}
else
{
hwbcEntries = default;
}
return(result);
}
public NvidiaGroup(ISettings settings)
{
if (NVML.IsAvailable)
{
report.AppendLine("NVML");
report.AppendLine();
if (NVML.GetNvmlVersionString(out string version) == NvmlReturn.SUCCESS)
{
report.Append("Version: ");
report.AppendLine(version);
}
NvmlReturn result = NVML.NvmlDeviceGetCount(out uint count);
if (result != NvmlReturn.SUCCESS)
{
report.AppendLine("Error: " + result);
report.AppendLine();
return;
}
report.Append("Number of GPUs: ");
report.AppendLine(count.ToString(CultureInfo.InvariantCulture));
for (uint i = 0; i < count; i++)
{
hardware.Add(new NvidiaGPU(i, settings));
}
report.AppendLine();
}
else if (NVAPI.IsAvailable)
{
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 NvidiaGPULegacy(i, handles[i], displayHandle, settings));
}
report.AppendLine();
}
}
/// <summary>
/// Constructs a new NVML exception.
/// </summary>
/// <param name="errorCode">The NVML runtime error.</param>
public NvmlException(NvmlReturn errorCode)
: base()
{
Error = errorCode;
}
