public override void Update()
{
base.Update();
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
for (uint i = 0; i < coreTemperatures.Length; i++)
{
if (Ring0.WritePciConfig(miscellaneousControlAddress, THERMTRIP_STATUS_REGISTER,
i > 0 ? thermSenseCoreSelCPU1 : thermSenseCoreSelCPU0))
{
uint value;
if (Ring0.ReadPciConfig(miscellaneousControlAddress, THERMTRIP_STATUS_REGISTER, out value))
{
coreTemperatures[i].Value = ((value >> 16) & 0xFF) + coreTemperatures[i].Parameters[0].Value;
ActivateSensor(coreTemperatures[i]);
}
else
{
DeactivateSensor(coreTemperatures[i]);
}
}
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (int i = 0; i < coreClocks.Length; i++)
{
Thread.Sleep(1);
uint eax, edx;
if (Ring0.RdmsrTx(FIDVID_STATUS, out eax, out edx,
1UL << cpuid[i][0].Thread))
{
// CurrFID can be found in eax bits 0-5, MaxFID in 16-21
// 8-13 hold StartFID, we don't use that here.
double curMP = 0.5 * ((eax & 0x3F) + 8);
double maxMP = 0.5 * ((eax >> 16 & 0x3F) + 8);
coreClocks[i].Value = (float)(curMP * TimeStampCounterFrequency / maxMP);
newBusClock = (float)(TimeStampCounterFrequency / maxMP);
}
else
{
// Fail-safe value - if the code above fails, we'll use this instead
coreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
if (newBusClock > 0)
{
this.busClock.Value = (float)newBusClock;
ActivateSensor(this.busClock);
}
}
}
private float[] GetTjMaxFromMSR()
{
float[] result = new float[coreCount];
for (int i = 0; i < coreCount; i++)
{
if (Ring0.RdmsrTx(IA32_TEMPERATURE_TARGET, out uint eax,
out _, cpuid[i][0].Affinity))
{
result[i] = (eax >> 16) & 0xFF;
}
private float[] GetTjMaxFromMsr()
{
var result = new float[CoreCount];
for (var i = 0; i < CoreCount; i++)
{
if (Ring0.RdmsrTx(Ia32TemperatureTarget, out var eax,
out _, 1UL << Cpuid[i][0].Thread))
{
result[i] = (eax >> 16) & 0xFF;
}
private float[] GetTjMaxFromMSR()
{
var result = new float[CoreCount];
for (var i = 0; i < CoreCount; i++)
{
if (Ring0.RdmsrTx(IA32_TEMPERATURE_TARGET, out var eax,
out _, 1UL << CpuId[i][0].Thread))
{
result[i] = (eax >> 16) & 0xFF;
}
private static void AppendMSRData(StringBuilder r, uint msr, GroupAffinity affinity)
{
if (Ring0.RdmsrTx(msr, out uint eax, out uint edx, affinity))
{
r.Append(" ");
r.Append((msr).ToString("X8", CultureInfo.InvariantCulture));
r.Append(" ");
r.Append((edx).ToString("X8", CultureInfo.InvariantCulture));
r.Append(" ");
r.Append((eax).ToString("X8", CultureInfo.InvariantCulture));
r.AppendLine();
}
}
public override void Update()
{
base.Update();
if (coreTemperatures.Any(temps => sensorConfig.GetSensorEvaluate(temps.IdentifierString)))
{
if (Ring0.WaitPciBusMutex(10))
{
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
for (uint i = 0; i < coreTemperatures.Length; i++)
{
if (Ring0.WritePciConfig(
miscellaneousControlAddress, THERMTRIP_STATUS_REGISTER,
i > 0 ? thermSenseCoreSelCPU1 : thermSenseCoreSelCPU0))
{
if (Ring0.ReadPciConfig(
miscellaneousControlAddress, THERMTRIP_STATUS_REGISTER,
out uint value))
{
coreTemperatures[i].Value = ((value >> 16) & 0xFF) +
coreTemperatures[i].Parameters[0].Value;
ActivateSensor(coreTemperatures[i]);
}
else
{
DeactivateSensor(coreTemperatures[i]);
}
}
}
}
Ring0.ReleasePciBusMutex();
}
}
if (coreClocks.Any(clocks => sensorConfig.GetSensorEvaluate(clocks.IdentifierString)) ||
sensorConfig.GetSensorEvaluate(coreMaxClocks.IdentifierString) ||
sensorConfig.GetSensorEvaluate(busClock.IdentifierString))
{
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (int i = 0; i < coreClocks.Length; i++)
{
Thread.Sleep(1);
if (Ring0.RdmsrTx(FIDVID_STATUS, out uint eax, out uint edx,
cpuid[i][0].Affinity))
private static void AppendMSRData(StringBuilder r, uint msr, int thread)
{
uint eax, edx;
if (Ring0.RdmsrTx(msr, out eax, out edx, 1UL << thread))
{
r.Append(" ");
r.Append((msr).ToString("X8", CultureInfo.InvariantCulture));
r.Append(" ");
r.Append((edx).ToString("X8", CultureInfo.InvariantCulture));
r.Append(" ");
r.Append((eax).ToString("X8", CultureInfo.InvariantCulture));
r.AppendLine();
}
}
public override void Update()
{
base.Update();
for (int i = 0; i < coreTemperatures.Length; i++)
{
// if reading is valid
if (Ring0.RdmsrTx(IA32_THERM_STATUS_MSR, out uint eax, out uint edx,
1UL << cpuid[i][0].Thread) && (eax & 0x80000000) != 0)
{
// get the dist from tjMax from bits 22:16
float deltaT = ((eax & 0x007F0000) >> 16);
float tjMax = coreTemperatures[i].Parameters[0].Value;
float tSlope = coreTemperatures[i].Parameters[1].Value;
coreTemperatures[i].Value = tjMax - tSlope * deltaT;
}
public override void Update()
{
base.Update();
if (_miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
for (uint i = 0; i < CoreTemperatures.Length; i++)
{
if (Ring0.WritePciConfig(
_miscellaneousControlAddress, ThermtripStatusRegister,
i > 0 ? _thermSenseCoreSelCpu1 : _thermSenseCoreSelCpu0))
{
if (Ring0.ReadPciConfig(
_miscellaneousControlAddress, ThermtripStatusRegister,
out var value))
{
CoreTemperatures[i].Value = ((value >> 16) & 0xFF) +
CoreTemperatures[i].Parameters[0].Value;
}
}
}
}
if (!HasTimeStampCounter)
{
return;
}
double newBusClock = 0;
for (var i = 0; i < CoreClocks.Length; i++)
{
Thread.Sleep(1);
if (Ring0.RdmsrTx(FidvidStatus, out var eax, out _,
1UL << Cpuid[i][0].Thread))
{
// CurrFID can be found in eax bits 0-5, MaxFID in 16-21
// 8-13 hold StartFID, we don't use that here.
var curMp = 0.5 * ((eax & 0x3F) + 8);
var maxMp = 0.5 * (((eax >> 16) & 0x3F) + 8);
CoreClocks[i].Value =
(float)(curMp * TimeStampCounterFrequency / maxMp);
newBusClock = (float)(TimeStampCounterFrequency / maxMp);
}
private float[] GetTjMaxFromMSR()
{
uint eax, edx;
float[] result = new float[coreCount];
for (int i = 0; i < coreCount; i++)
{
if (Ring0.RdmsrTx(IA32_TEMPERATURE_TARGET, out eax,
out edx, 1UL << cpuid[i][0].Thread))
{
result[i] = (eax >> 16) & 0xFF;
}
else
{
result[i] = 100;
}
}
return(result);
}
public override void Update()
{
base.Update();
if (supportCoreTemp)
{
for (int i = 0; i < coreCount; i++)
{
uint eax, edx;
// if reading is valid
if (Ring0.RdmsrTx(IA32_THERM_STATUS_MSR, out eax, out edx,
1UL << cpuid[i][0].Thread) && (eax & 0x80000000) != 0)
{
// get the dist from tjMax from bits 22:16
float deltaT = ((eax & 0x007F0000) >> 16);
coreTemps[i] = tjMax[i] - 1 * deltaT;
}
else
{
coreTemps[i] = 0;
}
}
}
if (supportPackageTemp)
{
uint eax, edx;
// if reading is valid
if (Ring0.RdmsrTx(IA32_PACKAGE_THERM_STATUS, out eax, out edx,
1UL << cpuid[0][0].Thread) && (eax & 0x80000000) != 0)
{
// get the dist from tjMax from bits 22:16
float deltaT = ((eax & 0x007F0000) >> 16);
packageTemp = tjMax[0] - 1 * deltaT;
}
else
{
packageTemp = 0;
}
}
}
public Core(int index, CPUID[] threads, AMD17CPU cpu, ISettings settings)
{
this.cpu = cpu;
this.threadAffinityMask = 1UL << threads[0].Thread;
string coreString = cpu.CoreString(index);
this.powerSensor =
new Sensor(coreString, index + 2, SensorType.Power, cpu, settings);
this.clockSensor =
new Sensor(coreString, index + 1, SensorType.Clock, cpu, settings);
if (cpu.energyUnitMultiplier != 0) {
if (Ring0.RdmsrTx(MSR_CORE_ENERGY_STAT, out uint energyConsumed,
out _, threadAffinityMask))
{
lastEnergyTime = DateTime.UtcNow;
lastEnergyConsumed = energyConsumed;
cpu.ActivateSensor(powerSensor);
}
}
}
public override void Update()
{
base.Update();
for (int i = 0; i < coreTemperatures.Length; i++)
{
uint eax, edx;
// if reading is valid
if (Ring0.RdmsrTx(IA32_THERM_STATUS_MSR, out eax, out edx,
1UL << cpuid[i][0].Thread) && (eax & 0x80000000) != 0)
{
// get the dist from tjMax from bits 22:16
float deltaT = ((eax & 0x007F0000) >> 16);
float tjMax = coreTemperatures[i].Parameters[0].Value;
float tSlope = coreTemperatures[i].Parameters[1].Value;
coreTemperatures[i].Value = tjMax - tSlope * deltaT;
}
else
{
coreTemperatures[i].Value = null;
}
}
if (packageTemperature != null)
{
uint eax, edx;
// if reading is valid
if (Ring0.RdmsrTx(IA32_PACKAGE_THERM_STATUS, out eax, out edx,
1UL << cpuid[0][0].Thread) && (eax & 0x80000000) != 0)
{
// get the dist from tjMax from bits 22:16
float deltaT = ((eax & 0x007F0000) >> 16);
float tjMax = packageTemperature.Parameters[0].Value;
float tSlope = packageTemperature.Parameters[1].Value;
packageTemperature.Value = tjMax - tSlope * deltaT;
}
else
{
packageTemperature.Value = null;
}
}
if (HasTimeStampCounter && timeStampCounterMultiplier > 0)
{
double newBusClock = 0;
uint eax, edx;
for (int i = 0; i < coreClocks.Length; i++)
{
System.Threading.Thread.Sleep(1);
if (Ring0.RdmsrTx(IA32_PERF_STATUS, out eax, out edx,
1UL << cpuid[i][0].Thread))
{
newBusClock =
TimeStampCounterFrequency / timeStampCounterMultiplier;
switch (microarchitecture)
{
case Microarchitecture.Nehalem: {
uint multiplier = eax & 0xff;
coreClocks[i].Value = (float)(multiplier * newBusClock);
} break;
case Microarchitecture.SandyBridge:
case Microarchitecture.IvyBridge:
case Microarchitecture.Haswell:
case Microarchitecture.Broadwell:
case Microarchitecture.Silvermont:
case Microarchitecture.Skylake: {
uint multiplier = (eax >> 8) & 0xff;
coreClocks[i].Value = (float)(multiplier * newBusClock);
} break;
default: {
double multiplier =
((eax >> 8) & 0x1f) + 0.5 * ((eax >> 14) & 1);
coreClocks[i].Value = (float)(multiplier * newBusClock);
} break;
}
}
else
{
// if IA32_PERF_STATUS is not available, assume TSC frequency
coreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
if (newBusClock > 0)
{
this.busClock.Value = (float)newBusClock;
ActivateSensor(this.busClock);
}
}
if (powerSensors != null)
{
foreach (Sensor sensor in powerSensors)
{
if (sensor == null)
{
continue;
}
uint eax, edx;
if (!Ring0.Rdmsr(energyStatusMSRs[sensor.Index], out eax, out edx))
{
continue;
}
DateTime time = DateTime.UtcNow;
uint energyConsumed = eax;
float deltaTime =
(float)(time - lastEnergyTime[sensor.Index]).TotalSeconds;
if (deltaTime < 0.01)
{
continue;
}
sensor.Value = energyUnitMultiplier *unchecked (
energyConsumed - lastEnergyConsumed[sensor.Index]) / deltaTime;
lastEnergyTime[sensor.Index] = time;
lastEnergyConsumed[sensor.Index] = energyConsumed;
}
}
}
public override void Update()
{
base.Update();
if (sensorConfig.GetSensorEvaluate(coreTemperature.IdentifierString))
{
if (temperatureStream == null)
{
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
uint value;
bool valueValid;
if (hasSmuTemperatureRegister)
{
valueValid =
ReadSmuRegister(SMU_REPORTED_TEMP_CONTROL_REGISTER, out value);
}
else
{
valueValid = Ring0.ReadPciConfig(miscellaneousControlAddress,
REPORTED_TEMPERATURE_CONTROL_REGISTER, out value);
}
if (valueValid)
{
if ((family == 0x15 || family == 0x16) && (value & 0x30000) == 0x30000)
{
coreTemperature.Value = ((value >> 21) & 0x7FF) * 0.125f +
coreTemperature.Parameters[0].Value - 49;
}
else
{
coreTemperature.Value = ((value >> 21) & 0x7FF) * 0.125f +
coreTemperature.Parameters[0].Value;
}
ActivateSensor(coreTemperature);
}
else
{
DeactivateSensor(coreTemperature);
}
}
}
else
{
string s = ReadFirstLine(temperatureStream);
try
{
coreTemperature.Value = 0.001f *
long.Parse(s, CultureInfo.InvariantCulture);
ActivateSensor(coreTemperature);
}
catch
{
DeactivateSensor(coreTemperature);
}
}
}
if (coreClocks.Any(clock => sensorConfig.GetSensorEvaluate(clock.IdentifierString)) ||
sensorConfig.GetSensorEvaluate(coreMaxClocks.IdentifierString) ||
sensorConfig.GetSensorEvaluate(busClock.IdentifierString))
{
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (int i = 0; i < coreClocks.Length; i++)
{
Thread.Sleep(1);
if (Ring0.RdmsrTx(COFVID_STATUS, out uint curEax, out uint curEdx,
cpuid[i][0].Affinity))
public override void Update()
{
base.Update();
if (temperatureStream == null)
{
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
uint value;
bool valueValid;
if (hasSmuTemperatureRegister)
{
valueValid =
ReadSmuRegister(SMU_REPORTED_TEMP_CONTROL_REGISTER, out value);
}
else
{
valueValid = Ring0.ReadPciConfig(miscellaneousControlAddress,
REPORTED_TEMPERATURE_CONTROL_REGISTER, out value);
}
if (valueValid)
{
if ((family == 0x15 || family == 0x16) && (value & 0x30000) == 0x30000)
{
coreTemperature.Value = ((value >> 21) & 0x7FF) * 0.125f +
coreTemperature.Parameters[0].Value - 49;
}
else
{
coreTemperature.Value = ((value >> 21) & 0x7FF) * 0.125f +
coreTemperature.Parameters[0].Value;
}
ActivateSensor(coreTemperature);
}
else
{
DeactivateSensor(coreTemperature);
}
}
}
else
{
string s = ReadFirstLine(temperatureStream);
try {
coreTemperature.Value = 0.001f *
long.Parse(s, CultureInfo.InvariantCulture);
ActivateSensor(coreTemperature);
} catch {
DeactivateSensor(coreTemperature);
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (int i = 0; i < coreClocks.Length; i++)
{
Thread.Sleep(1);
uint curEax, curEdx;
if (Ring0.RdmsrTx(COFVID_STATUS, out curEax, out curEdx,
cpuid[i][0].Affinity))
{
double multiplier;
multiplier = GetCoreMultiplier(curEax);
coreClocks[i].Value =
(float)(multiplier * TimeStampCounterFrequency /
timeStampCounterMultiplier);
newBusClock =
(float)(TimeStampCounterFrequency / timeStampCounterMultiplier);
}
else
{
coreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
if (newBusClock > 0)
{
this.busClock.Value = (float)newBusClock;
ActivateSensor(this.busClock);
}
}
}
public override void Update()
{
base.Update();
if (_temperatureStream == null)
{
if (_miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
uint value;
if (_miscellaneousControlAddress == Family15HModel60MiscControlDeviceId)
{
value = F15HM60HReportedTempCtrlOffset;
Ring0.WritePciConfig(Ring0.GetPciAddress(0, 0, 0), 0xB8, value);
Ring0.ReadPciConfig(Ring0.GetPciAddress(0, 0, 0), 0xBC, out value);
CoreTemperatures[0].Value = ((value >> 21) & 0x7FF) * 0.125f + CoreTemperatures[0].Parameters[0].Value;
return;
}
if (Ring0.ReadPciConfig(_miscellaneousControlAddress,
ReportedTemperatureControlRegister, out value))
{
if (Family == 0x15 && (value & 0x30000) == 0x30000)
{
if ((Model & 0xF0) == 0x00)
{
CoreTemperatures[0].Value = ((value >> 21) & 0x7FC) / 8.0f +
CoreTemperatures[0].Parameters[0].Value - 49;
}
else
{
CoreTemperatures[0].Value = ((value >> 21) & 0x7FF) / 8.0f +
CoreTemperatures[0].Parameters[0].Value - 49;
}
}
else if (Family == 0x16 &&
((value & 0x30000) == 0x30000 || (value & 0x80000) == 0x80000))
{
CoreTemperatures[0].Value = ((value >> 21) & 0x7FF) / 8.0f +
CoreTemperatures[0].Parameters[0].Value - 49;
}
else
{
CoreTemperatures[0].Value = ((value >> 21) & 0x7FF) / 8.0f +
CoreTemperatures[0].Parameters[0].Value;
}
}
}
}
else
{
var s = ReadFirstLine(_temperatureStream);
try
{
CoreTemperatures[0].Value = 0.001f * long.Parse(s, CultureInfo.InvariantCulture);
}
catch
{
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (var i = 0; i < CoreClocks.Length; i++)
{
Thread.Sleep(1);
uint curEdx;
if (Ring0.RdmsrTx(CofvidStatus, out var curEax, out curEdx,
1UL << Cpuid[i][0].Thread))
{
var multiplier = GetCoreMultiplier(curEax);
CoreClocks[i].Value =
(float)(multiplier * TimeStampCounterFrequency /
_timeStampCounterMultiplier);
newBusClock =
(float)(TimeStampCounterFrequency / _timeStampCounterMultiplier);
}
else
{
CoreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
public override void Update()
{
base.Update();
if (temperatureStream == null)
{
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
uint value;
if (Ring0.ReadPciConfig(miscellaneousControlAddress,
REPORTED_TEMPERATURE_CONTROL_REGISTER, out value))
{
if (family == 0x15 && (value & 0x30000) == 0x30000)
{
if ((model & 0xF0) == 0x00)
{
coreTemperature.Value = ((value >> 21) & 0x7FC) / 8.0f +
coreTemperature.Parameters[0].Value - 49;
}
else
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value - 49;
}
}
else if (family == 0x16 &&
((value & 0x30000) == 0x30000 || (value & 0x80000) == 0x80000))
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value - 49;
}
else
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value;
}
ActivateSensor(coreTemperature);
}
else
{
DeactivateSensor(coreTemperature);
}
}
}
else
{
var s = ReadFirstLine(temperatureStream);
try
{
coreTemperature.Value = 0.001f *
long.Parse(s, CultureInfo.InvariantCulture);
ActivateSensor(coreTemperature);
}
catch
{
DeactivateSensor(coreTemperature);
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (var i = 0; i < coreClocks.Length; i++)
{
Thread.Sleep(1);
uint curEax, curEdx;
if (Ring0.RdmsrTx(COFVID_STATUS, out curEax, out curEdx,
1UL << cpuid[i][0].Thread))
{
double multiplier;
multiplier = GetCoreMultiplier(curEax);
coreClocks[i].Value =
(float)(multiplier * TimeStampCounterFrequency /
timeStampCounterMultiplier);
newBusClock =
(float)(TimeStampCounterFrequency / timeStampCounterMultiplier);
}
else
{
coreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
if (newBusClock > 0)
{
busClock.Value = (float)newBusClock;
ActivateSensor(busClock);
}
}
}
public override void Update()
{
base.Update();
if (temperatureStream == null)
{
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
uint value;
if (miscellaneousControlAddress == FAMILY_15H_MODEL_60_MISC_CONTROL_DEVICE_ID)
{
Ring0.WritePciConfig(Ring0.GetPciAddress(0, 0, 0), 0xB8, F15H_M60H_REPORTED_TEMP_CTRL_OFFSET);
Ring0.ReadPciConfig(Ring0.GetPciAddress(0, 0, 0), 0xBC, out value);
}
else
{
Ring0.ReadPciConfig(miscellaneousControlAddress,
REPORTED_TEMPERATURE_CONTROL_REGISTER, out value);
}
if ((family == 0x15 || family == 0x16) && (value & 0x30000) == 0x3000)
{
if (family == 0x15 && (model & 0xF0) == 0x00)
{
coreTemperature.Value = ((value >> 21) & 0x7FC) / 8.0f +
coreTemperature.Parameters[0].Value - 49;
}
else
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value - 49;
}
}
else
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value;
}
ActivateSensor(coreTemperature);
}
else
{
DeactivateSensor(coreTemperature);
}
}
else
{
string s = ReadFirstLine(temperatureStream);
try {
coreTemperature.Value = 0.001f *
long.Parse(s, CultureInfo.InvariantCulture);
ActivateSensor(coreTemperature);
} catch {
DeactivateSensor(coreTemperature);
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
float maxCoreVoltage = 0, maxNBVoltage = 0;
for (int i = 0; i < coreClocks.Length; i++)
{
Thread.Sleep(1);
uint curEax, curEdx;
if (Ring0.RdmsrTx(COFVID_STATUS, out curEax, out curEdx, 1UL << cpuid[i][0].Thread))
{
double multiplier;
multiplier = GetCoreMultiplier(curEax);
coreClocks[i].Value =
(float)(multiplier * TimeStampCounterFrequency /
timeStampCounterMultiplier);
newBusClock =
(float)(TimeStampCounterFrequency / timeStampCounterMultiplier);
}
else
{
coreClocks[i].Value = (float)TimeStampCounterFrequency;
}
float SVI2Volt(uint vid) => vid < 0b1111_1000 ? 1.5500f - 0.00625f * vid : 0;
float SVI1Volt(uint vid) => vid < 0x7C ? 1.550f - 0.0125f * vid : 0;
float newCoreVoltage, newNBVoltage;
uint coreVid60 = (curEax >> 9) & 0x7F;
if (isSVI2)
{
newCoreVoltage = SVI2Volt(curEax >> 13 & 0x80 | coreVid60);
newNBVoltage = SVI2Volt(curEax >> 24);
}
else
{
newCoreVoltage = SVI1Volt(coreVid60);
newNBVoltage = SVI1Volt(curEax >> 25);
}
if (newCoreVoltage > maxCoreVoltage)
{
maxCoreVoltage = newCoreVoltage;
}
if (newNBVoltage > maxNBVoltage)
{
maxNBVoltage = newNBVoltage;
}
}
coreVoltage.Value = maxCoreVoltage;
northbridgeVoltage.Value = maxNBVoltage;
if (newBusClock > 0)
{
this.busClock.Value = (float)newBusClock;
ActivateSensor(this.busClock);
}
}
if (cStatesResidency != null)
{
for (int i = 0; i < cStatesResidency.Length; i++)
{
Ring0.WriteIoPort(cStatesIoPort, (byte)(cStatesIoOffset + i));
cStatesResidency[i].Value = Ring0.ReadIoPort(cStatesIoPort + 1) / 256f * 100;
}
}
}
public override void Update()
{
base.Update();
for (int i = 0; i < coreTemperatures.Length; i++)
{
uint eax, edx;
if (Ring0.RdmsrTx(
IA32_THERM_STATUS_MSR, out eax, out edx,
1UL << cpuid[i][0].Thread))
{
// if reading is valid
if ((eax & 0x80000000) != 0)
{
// get the dist from tjMax from bits 22:16
float deltaT = ((eax & 0x007F0000) >> 16);
float tjMax = coreTemperatures[i].Parameters[0].Value;
float tSlope = coreTemperatures[i].Parameters[1].Value;
coreTemperatures[i].Value = tjMax - tSlope * deltaT;
}
else
{
coreTemperatures[i].Value = null;
}
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
uint eax, edx;
for (int i = 0; i < coreClocks.Length; i++)
{
System.Threading.Thread.Sleep(1);
if (Ring0.RdmsrTx(IA32_PERF_STATUS, out eax, out edx,
1UL << cpuid[i][0].Thread))
{
newBusClock =
TimeStampCounterFrequency / timeStampCounterMultiplier;
switch (microarchitecture)
{
case Microarchitecture.Nehalem: {
uint multiplier = eax & 0xff;
coreClocks[i].Value = (float)(multiplier * newBusClock);
} break;
case Microarchitecture.SandyBridge: {
uint multiplier = (eax >> 8) & 0xff;
coreClocks[i].Value = (float)(multiplier * newBusClock);
} break;
default: {
double multiplier =
((eax >> 8) & 0x1f) + 0.5 * ((eax >> 14) & 1);
coreClocks[i].Value = (float)(multiplier * newBusClock);
} break;
}
}
else
{
// if IA32_PERF_STATUS is not available, assume TSC frequency
coreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
if (newBusClock > 0)
{
this.busClock.Value = (float)newBusClock;
ActivateSensor(this.busClock);
}
}
}
public override void Update()
{
base.Update();
if (temperatureStream == null)
{
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
uint value;
if (miscellaneousControlAddress == FAMILY_15H_MODEL_60_MISC_CONTROL_DEVICE_ID)
{
value = F15H_M60H_REPORTED_TEMP_CTRL_OFFSET;
Ring0.WritePciConfig(Ring0.GetPciAddress(0, 0, 0), 0xB8, value);
Ring0.ReadPciConfig(Ring0.GetPciAddress(0, 0, 0), 0xBC, out value);
CoreTemperatures[0].Value = ((value >> 21) & 0x7FF) * 0.125f +
CoreTemperatures[0].Parameters[0].Value;
ActivateSensor(CoreTemperatures[0]);
return;
}
if (Ring0.ReadPciConfig(miscellaneousControlAddress,
REPORTED_TEMPERATURE_CONTROL_REGISTER, out value))
{
if (family == 0x15 && (value & 0x30000) == 0x30000)
{
if ((model & 0xF0) == 0x00)
{
CoreTemperatures[0].Value = ((value >> 21) & 0x7FC) / 8.0f +
CoreTemperatures[0].Parameters[0].Value - 49;
}
else
{
CoreTemperatures[0].Value = ((value >> 21) & 0x7FF) / 8.0f +
CoreTemperatures[0].Parameters[0].Value - 49;
}
}
else if (family == 0x16 &&
((value & 0x30000) == 0x30000 || (value & 0x80000) == 0x80000))
{
CoreTemperatures[0].Value = ((value >> 21) & 0x7FF) / 8.0f +
CoreTemperatures[0].Parameters[0].Value - 49;
}
else
{
CoreTemperatures[0].Value = ((value >> 21) & 0x7FF) / 8.0f +
CoreTemperatures[0].Parameters[0].Value;
}
ActivateSensor(CoreTemperatures[0]);
}
else
{
DeactivateSensor(CoreTemperatures[0]);
}
}
}
else
{
var s = ReadFirstLine(temperatureStream);
try
{
CoreTemperatures[0].Value = 0.001f *
long.Parse(s, CultureInfo.InvariantCulture);
ActivateSensor(CoreTemperatures[0]);
}
catch
{
DeactivateSensor(CoreTemperatures[0]);
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (var i = 0; i < CoreClocks.Length; i++)
{
Thread.Sleep(1);
if (Ring0.RdmsrTx(COFVID_STATUS, out var curEax, out _,
1UL << CpuId[i][0].Thread))
{
var multiplier = GetCoreMultiplier(curEax);
CoreClocks[i].Value =
(float)(multiplier * TimeStampCounterFrequency /
timeStampCounterMultiplier);
newBusClock =
(float)(TimeStampCounterFrequency / timeStampCounterMultiplier);
}
else
{
CoreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
public override void Update()
{
base.Update();
if (temperatureStream == null)
{
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
uint value;
if (Ring0.ReadPciConfig(miscellaneousControlAddress,
REPORTED_TEMPERATURE_CONTROL_REGISTER, out value))
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value;
ActivateSensor(coreTemperature);
}
else
{
DeactivateSensor(coreTemperature);
}
}
}
else
{
string s = ReadFirstLine(temperatureStream);
try {
coreTemperature.Value = 0.001f *
long.Parse(s, CultureInfo.InvariantCulture);
ActivateSensor(coreTemperature);
} catch {
DeactivateSensor(coreTemperature);
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (int i = 0; i < coreClocks.Length; i++)
{
Thread.Sleep(1);
uint curEax, curEdx;
if (Ring0.RdmsrTx(COFVID_STATUS, out curEax, out curEdx,
1UL << cpuid[i][0].Thread))
{
double multiplier;
if (family == 0x14)
{
uint divisorIdMSD = (curEax >> 4) & 0x1F;
uint divisorIdLSD = curEax & 0xF;
uint value = 0;
Ring0.ReadPciConfig(miscellaneousControlAddress,
CLOCK_POWER_TIMING_CONTROL_0_REGISTER, out value);
uint frequencyId = value & 0x1F;
multiplier =
MultiplierFromIDs(divisorIdMSD, divisorIdLSD, frequencyId);
}
else
{
// 8:6 CpuDid: current core divisor ID
// 5:0 CpuFid: current core frequency ID
uint cpuDid = (curEax >> 6) & 7;
uint cpuFid = curEax & 0x1F;
multiplier = MultiplierFromIDs(cpuDid, cpuFid);
}
coreClocks[i].Value =
(float)(multiplier * TimeStampCounterFrequency /
timeStampCounterMultiplier);
newBusClock =
(float)(TimeStampCounterFrequency / timeStampCounterMultiplier);
}
else
{
coreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
if (newBusClock > 0)
{
this.busClock.Value = (float)newBusClock;
ActivateSensor(this.busClock);
}
}
}
public override void Update()
{
base.Update();
if (temperatureStream == null)
{
if (miscellaneousControlAddress != Ring0.InvalidPciAddress)
{
uint value;
if (family == 0x17)
{
// AMD 15f 60h-6Fh and AMD 17f use a different method of reading package temperature.
AmdNbIndexRead(0x60, F17H_M01H_REPORTED_TEMP_CTRL_OFFSET, out value);
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value;
if (!isZen2Triggered)
{
coreTemperature.Value -= -20f;//first gen ryzen 20deg offset
}
ActivateSensor(coreTemperature);
}
else
{
if (Ring0.ReadPciConfig(miscellaneousControlAddress,
REPORTED_TEMPERATURE_CONTROL_REGISTER, out value))
{
if (family == 0x15 && (value & 0x30000) == 0x30000)
{
if ((model & 0xF0) == 0x00)
{
coreTemperature.Value = ((value >> 21) & 0x7FC) / 8.0f +
coreTemperature.Parameters[0].Value - 49;
}
else
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value - 49;
}
}
else if (family == 0x16 &&
((value & 0x30000) == 0x30000 || (value & 0x80000) == 0x80000))
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value - 49;
}
else
{
coreTemperature.Value = ((value >> 21) & 0x7FF) / 8.0f +
coreTemperature.Parameters[0].Value;
}
ActivateSensor(coreTemperature);
}
else
{
DeactivateSensor(coreTemperature);
}
}
}
}
else
{
string s = ReadFirstLine(temperatureStream);
try {
coreTemperature.Value = 0.001f *
long.Parse(s, CultureInfo.InvariantCulture);
ActivateSensor(coreTemperature);
} catch {
DeactivateSensor(coreTemperature);
}
}
if (HasTimeStampCounter)
{
double newBusClock = 0;
for (int i = 0; i < coreClocks.Length; i++)
{
Thread.Sleep(1);
uint curEax, curEdx;
if (Ring0.RdmsrTx(COFVID_STATUS, out curEax, out curEdx,
1UL << cpuid[i][0].Thread))
{
double multiplier;
multiplier = GetCoreMultiplier(curEax);
coreClocks[i].Value =
(float)(multiplier * TimeStampCounterFrequency /
timeStampCounterMultiplier);
newBusClock =
(float)(TimeStampCounterFrequency / timeStampCounterMultiplier);
}
else
{
coreClocks[i].Value = (float)TimeStampCounterFrequency;
}
}
if (newBusClock > 0)
{
this.busClock.Value = (float)newBusClock;
ActivateSensor(this.busClock);
}
}
}
