249 lines
8.8 KiB
C#
249 lines
8.8 KiB
C#
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
|
|
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
// Copyright (C) LibreHardwareMonitor and Contributors.
|
|
// Partial Copyright (C) Michael Möller <mmoeller@openhardwaremonitor.org> and Contributors.
|
|
// All Rights Reserved.
|
|
|
|
using System;
|
|
using System.Text;
|
|
|
|
namespace LibreHardwareMonitor.Hardware.CPU
|
|
{
|
|
public enum Vendor
|
|
{
|
|
Unknown,
|
|
Intel,
|
|
AMD
|
|
}
|
|
|
|
public class CpuId
|
|
{
|
|
// ReSharper disable InconsistentNaming
|
|
public const uint CPUID_0 = 0;
|
|
public const uint CPUID_EXT = 0x80000000;
|
|
// ReSharper restore InconsistentNaming
|
|
|
|
public CpuId(int thread)
|
|
{
|
|
uint threadMaskWith;
|
|
uint coreMaskWith;
|
|
Thread = thread;
|
|
uint maxCpuidExt;
|
|
|
|
if (thread >= 64)
|
|
throw new ArgumentOutOfRangeException(nameof(thread));
|
|
|
|
|
|
ulong mask = 1UL << thread;
|
|
uint maxCpuid;
|
|
if (OpCode.CpuidTx(CPUID_0, 0, out uint eax, out uint ebx, out uint ecx, out uint edx, mask))
|
|
{
|
|
if (eax > 0)
|
|
maxCpuid = eax;
|
|
else
|
|
return;
|
|
|
|
|
|
StringBuilder vendorBuilder = new StringBuilder();
|
|
AppendRegister(vendorBuilder, ebx);
|
|
AppendRegister(vendorBuilder, edx);
|
|
AppendRegister(vendorBuilder, ecx);
|
|
string cpuVendor = vendorBuilder.ToString();
|
|
switch (cpuVendor)
|
|
{
|
|
case "GenuineIntel":
|
|
Vendor = Vendor.Intel;
|
|
break;
|
|
case "AuthenticAMD":
|
|
Vendor = Vendor.AMD;
|
|
break;
|
|
default:
|
|
Vendor = Vendor.Unknown;
|
|
break;
|
|
}
|
|
|
|
if (OpCode.CpuidTx(CPUID_EXT, 0, out eax, out _, out _, out _, mask))
|
|
{
|
|
if (eax > CPUID_EXT)
|
|
maxCpuidExt = eax - CPUID_EXT;
|
|
else
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(thread));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(thread));
|
|
}
|
|
|
|
maxCpuid = Math.Min(maxCpuid, 1024);
|
|
maxCpuidExt = Math.Min(maxCpuidExt, 1024);
|
|
|
|
Data = new uint[maxCpuid + 1, 4];
|
|
for (uint i = 0; i < maxCpuid + 1; i++)
|
|
{
|
|
OpCode.CpuidTx(CPUID_0 + i, 0, out Data[i, 0], out Data[i, 1], out Data[i, 2], out Data[i, 3], mask);
|
|
}
|
|
|
|
ExtData = new uint[maxCpuidExt + 1, 4];
|
|
for (uint i = 0; i < maxCpuidExt + 1; i++)
|
|
{
|
|
OpCode.CpuidTx(CPUID_EXT + i, 0, out ExtData[i, 0], out ExtData[i, 1], out ExtData[i, 2], out ExtData[i, 3], mask);
|
|
}
|
|
|
|
StringBuilder nameBuilder = new StringBuilder();
|
|
for (uint i = 2; i <= 4; i++)
|
|
{
|
|
if (OpCode.CpuidTx(CPUID_EXT + i, 0, out eax, out ebx, out ecx, out edx, mask))
|
|
{
|
|
AppendRegister(nameBuilder, eax);
|
|
AppendRegister(nameBuilder, ebx);
|
|
AppendRegister(nameBuilder, ecx);
|
|
AppendRegister(nameBuilder, edx);
|
|
}
|
|
}
|
|
|
|
nameBuilder.Replace('\0', ' ');
|
|
BrandString = nameBuilder.ToString().Trim();
|
|
nameBuilder.Replace("(R)", string.Empty);
|
|
nameBuilder.Replace("(TM)", string.Empty);
|
|
nameBuilder.Replace("(tm)", string.Empty);
|
|
nameBuilder.Replace("CPU", string.Empty);
|
|
nameBuilder.Replace("Dual-Core Processor", string.Empty);
|
|
nameBuilder.Replace("Triple-Core Processor", string.Empty);
|
|
nameBuilder.Replace("Quad-Core Processor", string.Empty);
|
|
nameBuilder.Replace("Six-Core Processor", string.Empty);
|
|
nameBuilder.Replace("Eight-Core Processor", string.Empty);
|
|
nameBuilder.Replace("6-Core Processor", string.Empty);
|
|
nameBuilder.Replace("8-Core Processor", string.Empty);
|
|
nameBuilder.Replace("12-Core Processor", string.Empty);
|
|
nameBuilder.Replace("16-Core Processor", string.Empty);
|
|
nameBuilder.Replace("24-Core Processor", string.Empty);
|
|
nameBuilder.Replace("32-Core Processor", string.Empty);
|
|
nameBuilder.Replace("64-Core Processor", string.Empty);
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
nameBuilder.Replace(" ", " ");
|
|
|
|
Name = nameBuilder.ToString();
|
|
if (Name.Contains("@"))
|
|
Name = Name.Remove(Name.LastIndexOf('@'));
|
|
|
|
Name = Name.Trim();
|
|
Family = ((Data[1, 0] & 0x0FF00000) >> 20) + ((Data[1, 0] & 0x0F00) >> 8);
|
|
Model = ((Data[1, 0] & 0x0F0000) >> 12) + ((Data[1, 0] & 0xF0) >> 4);
|
|
Stepping = Data[1, 0] & 0x0F;
|
|
ApicId = (Data[1, 1] >> 24) & 0xFF;
|
|
|
|
switch (Vendor)
|
|
{
|
|
case Vendor.Intel:
|
|
uint maxCoreAndThreadIdPerPackage = (Data[1, 1] >> 16) & 0xFF;
|
|
uint maxCoreIdPerPackage;
|
|
if (maxCpuid >= 4)
|
|
maxCoreIdPerPackage = ((Data[4, 0] >> 26) & 0x3F) + 1;
|
|
else
|
|
maxCoreIdPerPackage = 1;
|
|
|
|
threadMaskWith = NextLog2(maxCoreAndThreadIdPerPackage / maxCoreIdPerPackage);
|
|
coreMaskWith = NextLog2(maxCoreIdPerPackage);
|
|
break;
|
|
case Vendor.AMD:
|
|
uint corePerPackage;
|
|
if (maxCpuidExt >= 8)
|
|
corePerPackage = (ExtData[8, 2] & 0xFF) + 1;
|
|
else
|
|
corePerPackage = 1;
|
|
|
|
threadMaskWith = 0;
|
|
coreMaskWith = NextLog2(corePerPackage);
|
|
|
|
if (Family == 0x17)
|
|
{
|
|
// ApicIdCoreIdSize: APIC ID size.
|
|
// cores per DIE
|
|
// we need this for Ryzen 5 (4 cores, 8 threads) ans Ryzen 6 (6 cores, 12 threads)
|
|
// Ryzen 5: [core0][core1][dummy][dummy][core2][core3] (Core0 EBX = 00080800, Core2 EBX = 08080800)
|
|
uint maxCoresPerDie = (ExtData[8, 2] >> 12) & 0xF;
|
|
switch (maxCoresPerDie)
|
|
{
|
|
case 0x04: // Ryzen
|
|
coreMaskWith = NextLog2(16);
|
|
break;
|
|
case 0x05: // Threadripper
|
|
coreMaskWith = NextLog2(32);
|
|
break;
|
|
case 0x06: // Epic
|
|
coreMaskWith = NextLog2(64);
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
default:
|
|
threadMaskWith = 0;
|
|
coreMaskWith = 0;
|
|
break;
|
|
}
|
|
|
|
ProcessorId = ApicId >> (int)(coreMaskWith + threadMaskWith);
|
|
CoreId = (ApicId >> (int)threadMaskWith) - (ProcessorId << (int)coreMaskWith);
|
|
ThreadId = ApicId - (ProcessorId << (int)(coreMaskWith + threadMaskWith)) - (CoreId << (int)threadMaskWith);
|
|
}
|
|
|
|
public uint ApicId { get; }
|
|
|
|
public string BrandString { get; } = string.Empty;
|
|
|
|
public uint CoreId { get; }
|
|
|
|
public uint[,] Data { get; } = new uint[0, 0];
|
|
|
|
public uint[,] ExtData { get; } = new uint[0, 0];
|
|
|
|
public uint Family { get; }
|
|
|
|
public uint Model { get; }
|
|
|
|
public string Name { get; } = string.Empty;
|
|
|
|
public uint ProcessorId { get; }
|
|
|
|
public uint Stepping { get; }
|
|
|
|
public int Thread { get; }
|
|
|
|
public uint ThreadId { get; }
|
|
|
|
public Vendor Vendor { get; } = Vendor.Unknown;
|
|
|
|
private static void AppendRegister(StringBuilder b, uint value)
|
|
{
|
|
b.Append((char)(value & 0xff));
|
|
b.Append((char)((value >> 8) & 0xff));
|
|
b.Append((char)((value >> 16) & 0xff));
|
|
b.Append((char)((value >> 24) & 0xff));
|
|
}
|
|
|
|
private static uint NextLog2(long x)
|
|
{
|
|
if (x <= 0)
|
|
return 0;
|
|
|
|
|
|
x--;
|
|
uint count = 0;
|
|
while (x > 0)
|
|
{
|
|
x >>= 1;
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
}
|
|
}
|