public float?GetSensorValue(int deviceIndex, SensorType sensorType)
{
int overdriveVersion = overdriveVersionList[deviceIndex];
if (overdriveVersion >= 8)
{
int sensorIndex = (int)PMLogSensorMap[(int)sensorType];
if (ADL2_New_QueryPMLogData_Get(context, adapterInfoList[deviceIndex].AdapterIndex, out var data) < 0 ||
sensorIndex >= data.Sensors.Length ||
!data.Sensors[sensorIndex].Supported)
{
return(null);
}
return(data.Sensors[sensorIndex].Value);
}
switch (sensorType)
{
case SensorType.GFX_LOAD:
ADLPMActivity ADLPMact = new ADLPMActivity();
if (overdriveVersion >= 5 && ADL_Overdrive5_CurrentActivity_Get(deviceIndex, ref ADLPMact) == 0)
{
return(ADLPMact.ActivityPercent / 100.0f);
}
break;
case SensorType.GFX_TEMPERATURE:
if (overdriveVersion >= 7 && ADL2_OverdriveN_Temperature_Get(context, deviceIndex, PMLogSensorMap[(int)sensorType], out int temperature) == 0)
{
return(temperature * 0.001f);
}
ADLTemperature ADLTemp = new ADLTemperature();
if (ADL_Overdrive5_Temperature_Get(deviceIndex, 0, ref ADLTemp) == 0)
{
return(ADLTemp.Temperature * 0.001f);
}
break;
case SensorType.GFX_POWER:
if (overdriveVersion >= 6 && ADL2_Overdrive6_CurrentPower_Get(context, deviceIndex, ODNSensorMap[(int)sensorType], out int power) == 0)
{
return(power * (1.0f / 0xff));
}
break;
}
return(null);
}
}; // Keep everything until the miner quits.
public static bool InitializeADL(OpenCLDevice[] mDevices)
{
var ADLRet = -1;
var NumberOfAdapters = 0;
if (null != ADL.ADL_Main_Control_Create)
{
ADLRet = ADL.ADL_Main_Control_Create(ADL.ADL_Main_Memory_Alloc, 1);
}
if (ADL.ADL_SUCCESS == ADLRet)
{
MainForm.Logger("Successfully initialized AMD Display Library.");
if (null != ADL.ADL_Adapter_NumberOfAdapters_Get)
{
ADL.ADL_Adapter_NumberOfAdapters_Get(ref NumberOfAdapters);
}
MainForm.Logger("Number of ADL Adapters: " + NumberOfAdapters.ToString());
if (0 < NumberOfAdapters)
{
ADLAdapterInfoArray OSAdapterInfoData;
OSAdapterInfoData = new ADLAdapterInfoArray();
if (null == ADL.ADL_Adapter_AdapterInfo_Get)
{
MainForm.Logger("ADL.ADL_Adapter_AdapterInfo_Get() is not available.");
}
else
{
var AdapterBuffer = IntPtr.Zero;
var size = Marshal.SizeOf(OSAdapterInfoData);
AdapterBuffer = Marshal.AllocCoTaskMem((int)size);
Marshal.StructureToPtr(OSAdapterInfoData, AdapterBuffer, false);
ADLRet = ADL.ADL_Adapter_AdapterInfo_Get(AdapterBuffer, size);
if (ADL.ADL_SUCCESS == ADLRet)
{
OSAdapterInfoData = (ADLAdapterInfoArray)Marshal.PtrToStructure(AdapterBuffer, OSAdapterInfoData.GetType());
bool adrenalineWorkaroundRequired = false;
foreach (var device in mDevices)
{
var openclDevice = device.GetComputeDevice();
if (device.GetVendor() == "AMD" && openclDevice.PciBusIdAMD <= 0)
{
adrenalineWorkaroundRequired = true;
}
}
if (adrenalineWorkaroundRequired)
{
// workaround for Adrenalin drivers as PciBusIdAMD does not work properly.
MainForm.Logger("Manually matching OpenCL devices with ADL devices...");
List <int> taken = new List <int> {
};
foreach (var device in mDevices)
{
var openclDevice = device.GetComputeDevice();
if (device.GetVendor() == "AMD")
{
string boardName = (new System.Text.RegularExpressions.Regex("[^a-zA-Z0-9]+$")).Replace(System.Text.Encoding.ASCII.GetString(openclDevice.BoardNameAMD), ""); // Drop '\0'
int boardCounter = 0;
for (var i = 0; i < NumberOfAdapters; ++i)
{
if (OSAdapterInfoData.ADLAdapterInfo[i].AdapterName == boardName && !taken.Contains(OSAdapterInfoData.ADLAdapterInfo[i].BusNumber))
{
boardCounter++;
}
while (i + 1 < NumberOfAdapters && OSAdapterInfoData.ADLAdapterInfo[i].BusNumber == OSAdapterInfoData.ADLAdapterInfo[i + 1].BusNumber)
{
++i;
}
}
if (boardCounter <= 1)
{
for (var i = 0; i < NumberOfAdapters; ++i)
{
if (OSAdapterInfoData.ADLAdapterInfo[i].AdapterName == boardName && !taken.Contains(OSAdapterInfoData.ADLAdapterInfo[i].BusNumber))
{
device.ADLAdapterIndex = i;
taken.Add(OSAdapterInfoData.ADLAdapterInfo[i].BusNumber);
break;
}
while (i + 1 < NumberOfAdapters && OSAdapterInfoData.ADLAdapterInfo[i].BusNumber == OSAdapterInfoData.ADLAdapterInfo[i + 1].BusNumber)
{
++i;
}
}
}
else
{
OpenCLDummyLbryMiner dummyMiner = new OpenCLDummyLbryMiner(device);
dummyMinerList.Add(dummyMiner);
dummyMiner.Start();
int[] activityTotalArray = new int[NumberOfAdapters];
for (var i = 0; i < NumberOfAdapters; ++i)
{
activityTotalArray[i] = 0;
}
for (var j = 0; j < 10; ++j)
{
for (var i = 0; i < NumberOfAdapters; ++i)
{
if (OSAdapterInfoData.ADLAdapterInfo[i].AdapterName == boardName && !taken.Contains(OSAdapterInfoData.ADLAdapterInfo[i].BusNumber))
{
ADLPMActivity OSADLPMActivityData;
OSADLPMActivityData = new ADLPMActivity();
var activityBuffer = IntPtr.Zero;
size = Marshal.SizeOf(OSADLPMActivityData);
activityBuffer = Marshal.AllocCoTaskMem((int)size);
Marshal.StructureToPtr(OSADLPMActivityData, activityBuffer, false);
if (null != ADL.ADL_Overdrive5_CurrentActivity_Get)
{
ADLRet = ADL.ADL_Overdrive5_CurrentActivity_Get(i, activityBuffer);
if (ADL.ADL_SUCCESS == ADLRet)
{
OSADLPMActivityData = (ADLPMActivity)Marshal.PtrToStructure(activityBuffer, OSADLPMActivityData.GetType());
activityTotalArray[i] += OSADLPMActivityData.iActivityPercent;
}
}
}
while (i + 1 < NumberOfAdapters && OSAdapterInfoData.ADLAdapterInfo[i].BusNumber == OSAdapterInfoData.ADLAdapterInfo[i + 1].BusNumber)
{
++i;
}
}
System.Threading.Thread.Sleep(100);
}
int candidate = -1;
int candidateActivity = 0;
for (var i = 0; i < NumberOfAdapters; ++i)
{
if (OSAdapterInfoData.ADLAdapterInfo[i].AdapterName == boardName && !taken.Contains(OSAdapterInfoData.ADLAdapterInfo[i].BusNumber))
{
if (candidate < 0 || activityTotalArray[i] > candidateActivity)
{
candidateActivity = activityTotalArray[i];
candidate = i;
}
}
while (i + 1 < NumberOfAdapters && OSAdapterInfoData.ADLAdapterInfo[i].BusNumber == OSAdapterInfoData.ADLAdapterInfo[i + 1].BusNumber)
{
++i;
}
}
device.ADLAdapterIndex = candidate;
taken.Add(OSAdapterInfoData.ADLAdapterInfo[candidate].BusNumber);
dummyMiner.Stop();
for (int i = 0; i < 50; ++i)
{
if (dummyMiner.Stopped)
{
break;
}
System.Threading.Thread.Sleep(100);
}
if (!dummyMiner.Stopped)
{
MainForm.Logger("Failed at matching OpenCL devices with ADL devices. Restarting...");
System.Windows.Forms.Application.Exit();
}
}
}
}
}
else
{
// Use openclDevice.PciBusIdAMD for matching.
foreach (var device in mDevices)
{
var openclDevice = device.GetComputeDevice();
if (device.GetVendor() == "AMD")
{
for (var i = 0; i < NumberOfAdapters; i++)
{
var IsActive = 0;
if (null != ADL.ADL_Adapter_Active_Get)
{
ADLRet = ADL.ADL_Adapter_Active_Get(OSAdapterInfoData.ADLAdapterInfo[i].AdapterIndex, ref IsActive);
}
if (OSAdapterInfoData.ADLAdapterInfo[i].BusNumber == openclDevice.PciBusIdAMD &&
(device.ADLAdapterIndex < 0 || IsActive != 0))
{
device.ADLAdapterIndex = OSAdapterInfoData.ADLAdapterInfo[i].AdapterIndex;
}
}
}
}
}
}
else
{
MainForm.Logger("ADL_Adapter_AdapterInfo_Get() returned error code " + ADLRet.ToString());
}
// Release the memory for the AdapterInfo structure
if (IntPtr.Zero != AdapterBuffer)
{
Marshal.FreeCoTaskMem(AdapterBuffer);
}
}
}
return(true);
}
else
{
MainForm.Logger("Failed to initialize AMD Display Library.");
return(false);
}
}
public static extern int ADL_Overdrive5_CurrentActivity_Get(int iAdapterIndex, ref ADLPMActivity activity);
public override void Update()
{
ADLTemperature adlt = new ADLTemperature();
if (ADL.ADL_Overdrive5_Temperature_Get(adapterIndex, 0, ref adlt)
== ADL.ADL_OK)
{
temperature.Value = 0.001f * adlt.Temperature;
ActivateSensor(temperature);
} else {
temperature.Value = null;
}
ADLFanSpeedValue adlf = new ADLFanSpeedValue();
adlf.SpeedType = ADL.ADL_DL_FANCTRL_SPEED_TYPE_RPM;
if (ADL.ADL_Overdrive5_FanSpeed_Get(adapterIndex, 0, ref adlf)
== ADL.ADL_OK)
{
fan.Value = adlf.FanSpeed;
ActivateSensor(fan);
} else {
fan.Value = null;
}
adlf = new ADLFanSpeedValue();
adlf.SpeedType = ADL.ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;
if (ADL.ADL_Overdrive5_FanSpeed_Get(adapterIndex, 0, ref adlf)
== ADL.ADL_OK) {
controlSensor.Value = adlf.FanSpeed;
ActivateSensor(controlSensor);
} else {
controlSensor.Value = null;
}
ADLPMActivity adlp = new ADLPMActivity();
if (ADL.ADL_Overdrive5_CurrentActivity_Get(adapterIndex, ref adlp)
== ADL.ADL_OK)
{
if (adlp.EngineClock > 0) {
coreClock.Value = 0.01f * adlp.EngineClock;
ActivateSensor(coreClock);
} else {
coreClock.Value = null;
}
if (adlp.MemoryClock > 0) {
memoryClock.Value = 0.01f * adlp.MemoryClock;
ActivateSensor(memoryClock);
} else {
memoryClock.Value = null;
}
if (adlp.Vddc > 0) {
coreVoltage.Value = 0.001f * adlp.Vddc;
ActivateSensor(coreVoltage);
} else {
coreVoltage.Value = null;
}
coreLoad.Value = Math.Min(adlp.ActivityPercent, 100);
ActivateSensor(coreLoad);
} else {
coreClock.Value = null;
memoryClock.Value = null;
coreVoltage.Value = null;
coreLoad.Value = null;
}
}
static void Main(string[] args)
{
IntPtr context = IntPtr.Zero;
const int adapterIndex = 1;
ADL_Main_Control_Create(1);
int supported = 0;
int enabled = 0;
int version = 0;
if (ADL_OK == ADL_Overdrive_Caps(adapterIndex, ref supported, ref enabled, ref version))
{
Console.WriteLine("supported: {0:D}", supported);
Console.WriteLine("enabled: {0:D}", enabled);
Console.WriteLine("version: {0:D}", version);
Console.WriteLine("----------------------------------");
}
if (ADL2_Main_Control_Create(Main_Memory_Alloc, adapterIndex, ref context) == ADL_OK)
{
Console.WriteLine("Context is: {0:D}", context);
if (ADL_OK == ADL2_Overdrive_Caps(context, adapterIndex, ref supported, ref enabled, ref version))
{
Console.WriteLine("v2 supported: {0:D}", supported);
Console.WriteLine("v2 enabled: {0:D}", enabled);
Console.WriteLine("v2 version: {0:D}", version);
Console.WriteLine("----------------------------------");
}
int isAccessible = 0;
if (ADL2_Adapter_Accessibility_Get(context, adapterIndex, ref isAccessible) == ADL_OK)
{
Console.WriteLine("Adapter is accesible: {0:D}", isAccessible);
}
for (var powerIndex = 0; powerIndex < 4; powerIndex++)
{
int power = 0;
if (ADL2_Overdrive6_CurrentPower_Get(context, adapterIndex, powerIndex, ref power) == ADL_OK)
{
Console.WriteLine("power query of {0:D} is => {1:F1}", powerIndex, power / 256f);
}
else
{
Console.WriteLine("power query error: {0:D}", powerIndex);
}
}
ADLODNPerformanceStatus performanceStatus = new ADLODNPerformanceStatus();
if (ADL2_OverdriveN_PerformanceStatus_Get(context, adapterIndex, ref performanceStatus) == ADL_OK)
{
Console.WriteLine("-------------");
Console.WriteLine("perf status:");
Console.WriteLine("\tcurrent bus speed => {0:D}", performanceStatus.iCurrentBusSpeed);
Console.WriteLine("\tcurrent bus lanes => {0:D}", performanceStatus.iCurrentBusLanes);
Console.WriteLine("\tmaximum bus lanes => {0:D}", performanceStatus.iMaximumBusLanes);
Console.WriteLine("\tgpu activity percent => {0:D}", performanceStatus.iGPUActivityPercent);
Console.WriteLine("\tcurrent core perf. level => {0:D}", performanceStatus.iCurrentCorePerformanceLevel);
Console.WriteLine("\tcurrent dcef perf. level => {0:D}", performanceStatus.iCurrentDCEFPerformanceLevel);
Console.WriteLine("\tcurrent gfx perf. level => {0:D}", performanceStatus.iCurrentGFXPerformanceLevel);
Console.WriteLine("\tcurrent mem. perf. level => {0:D}", performanceStatus.iCurrentMemoryPerformanceLevel);
Console.WriteLine("\tcore clock => {0:D}", performanceStatus.iCoreClock);
Console.WriteLine("\tdcef clock => {0:D}", performanceStatus.iDCEFClock);
Console.WriteLine("\tgxf clock => {0:D}", performanceStatus.iGFXClock);
Console.WriteLine("\tmem. clock => {0:D}", performanceStatus.iMemoryClock);
Console.WriteLine("\tuvd clock => {0:D}", performanceStatus.iUVDClock);
Console.WriteLine("\tuvd perf. level => {0:D}", performanceStatus.iUVDPerformanceLevel);
Console.WriteLine("\tvce clock => {0:D}", performanceStatus.iVCEClock);
Console.WriteLine("\tvce perf level => {0:D}", performanceStatus.iVCEPerformanceLevel);
Console.WriteLine("\tvddc => {0:D}", performanceStatus.iVDDC);
Console.WriteLine("\tvddci => {0:D}", performanceStatus.iVDDCI);
Console.WriteLine("-------------");
}
ADLPMActivity activity = new ADLPMActivity();
if (ADL_Overdrive5_CurrentActivity_Get(adapterIndex, ref activity) == ADL_OK)
{
Console.WriteLine("-------------");
Console.WriteLine("activity:");
Console.WriteLine("\tacivity percent => {0:D}", activity.iActivityPercent);
Console.WriteLine("\tcurrent bus lanes => {0:D}", activity.iCurrentBusLanes);
Console.WriteLine("\tcurrent bus speed => {0:D}", activity.iCurrentBusSpeed);
Console.WriteLine("\tcurrent perf. level => {0:D}", activity.iCurrentPerformanceLevel);
Console.WriteLine("\tengine clock => {0:D}", activity.iEngineClock);
Console.WriteLine("\tmax. bus lanes => {0:D}", activity.iMaximumBusLanes);
Console.WriteLine("\tmemory clock => {0:D}", activity.iMemoryClock);
Console.WriteLine("\treserved => {0:D}", activity.iReserved);
Console.WriteLine("\tsize => {0:D}", activity.iSize);
Console.WriteLine("\tvddc => {0:D}", activity.iVddc);
Console.WriteLine("-------------");
}
Console.WriteLine("-------------");
Console.WriteLine("teperatures:");
foreach (var sensor in GPUTemperatureSensorIndexes)
{
int temp = 0;
//ADLTemperature adlt = new ADLTemperature();
//if (ADL_Overdrive5_Temperature_Get(1, 0, ref adlt) == ADL_OK)
int res = ADL2_OverdriveN_Temperature_Get(context, adapterIndex, sensor.Key, ref temp);
if (res == ADL_OK)
{
if (sensor.Key == 1)
{
temp /= 1000;
}
Console.WriteLine("\t{0:S} Temperature: {1:D}", sensor.Value, temp);
//Console.WriteLine(adlt.Temperature);
}
else
{
Console.WriteLine("error: {0:D}", res);
}
}
Console.WriteLine("-------------");
Console.WriteLine("log data (without settings check):");
ADLPMLogDataOutput logDataOutput = new ADLPMLogDataOutput();
if (ADL2_New_QueryPMLogData_Get(context, adapterIndex, ref logDataOutput) == ADL_OK)
{
Console.WriteLine("\tLog Data Output size: {0:D}", logDataOutput.size);
for (int i = 0; i < logDataOutput.size; i++)
{
Console.WriteLine("\tSensor type: {0:S} Value: {1:D}", Enum.GetName(typeof(ADLSensorType), i), logDataOutput.sensors[i].value);
}
}
ADL2_Main_Control_Destroy(context);
ADL_Main_Control_Destroy();
}
else
{
Console.WriteLine("Alloc failed");
}
Console.ReadKey();
}
