/****************************************************************************
DESCRIPTION:
Returns the speed of the processor in MHz.
HEADER:
cpuinfo.h
PARAMETERS:
accurate - True of the speed should be measured accurately
RETURNS:
Processor speed in MHz.
REMARKS:
This function returns the speed of the CPU in MHz. Note that if the speed
cannot be determined, this function will return 0.
If the accurate parameter is set to true, this function will spend longer
profiling the speed of the CPU, and will not round the CPU speed that is
reported. This is important for highly accurate timing using the Pentium
RDTSC instruction, but it does take a lot longer for the profiling to
produce accurate results.
SEE ALSO:
CPU_getProcessorSpeedInHz, CPU_getProcessorType, CPU_haveMMX,
CPU_getProcessorName
****************************************************************************/
ulong ZAPI CPU_getProcessorSpeed(
ibool accurate)
{
#if defined(__INTEL__)
/* Number of cycles needed to execute a single BSF instruction on i386+
* processors.
*/
u64 speed64;
ulong cpuSpeed;
uint i;
static ulong intel_cycles[] = {
115,47,43,
};
static ulong cyrix_cycles[] = {
38,38,52,52,
};
static ulong amd_cycles[] = {
49,
};
static ulong known_speeds[] = {
2000,1800,1700,1600,1500,1400,1300,1200,1100,1000,950,900,850,800,750,
700,650,600,550,500,450,433,400,350,333,300,266,233,200,166,150,133,
120,100,90,75,66,60,50,33,20,0,
};
if (CPU_haveRDTSC()) {
GetRDTSCCpuSpeed(accurate, &speed64);
PM_div64_32(speed64, speed64, 1000000);
cpuSpeed = PM_getlo32(speed64);
}
else {
int type = CPU_getProcessorType();
int processor = type & CPU_mask;
int vendor = type & CPU_familyMask;
if (vendor == CPU_Intel)
cpuSpeed = GetBSFCpuSpeed(ITERATIONS * intel_cycles[processor - CPU_i386]);
else if (vendor == CPU_Cyrix)
cpuSpeed = GetBSFCpuSpeed(ITERATIONS * cyrix_cycles[processor - CPU_Cyrix6x86]);
else if (vendor == CPU_AMD)
cpuSpeed = GetBSFCpuSpeed(ITERATIONS * amd_cycles[0]);
else
return 0;
}
/* Now normalise the results given known processors speeds, if the
* speed we measure is within 2MHz of the expected values
*/
if (!accurate) {
for (i = 0; known_speeds[i] != 0; i++) {
if (cpuSpeed >= (known_speeds[i]-3) && cpuSpeed <= (known_speeds[i]+3)) {
return known_speeds[i];
}
}
}
return cpuSpeed;
#else
return 0;
#endif
}
/****************************************************************************
DESCRIPTION:
Returns a string defining the speed and name of the processor.
HEADER:
ztimer.h
RETURNS:
Processor name string.
REMARKS:
This function returns an English string describing the speed and name of the
CPU.
SEE ALSO:
CPU_getProcessorType, CPU_haveMMX, CPU_getProcessorName
****************************************************************************/
char * ZAPI CPU_getProcessorName(void)
{
#if defined(__INTEL__)
static int cpu,speed = -1;
static char name[80];
if (speed == -1) {
cpu = CPU_getProcessorType();
speed = CPU_getProcessorSpeed(false);
}
sprintf(name,"%d MHz ", speed);
switch (cpu & CPU_mask) {
case CPU_i386:
strcat(name,"Intel i386 processor");
break;
case CPU_i486:
strcat(name,"Intel i486 processor");
break;
case CPU_Pentium:
strcat(name,"Intel Pentium processor");
break;
case CPU_PentiumPro:
strcat(name,"Intel Pentium Pro processor");
break;
case CPU_PentiumII:
strcat(name,"Intel Pentium II processor");
break;
case CPU_Celeron:
strcat(name,"Intel Celeron processor");
break;
case CPU_PentiumIII:
strcat(name,"Intel Pentium III processor");
break;
case CPU_UnkIntel:
strcat(name,"Unknown Intel processor");
break;
case CPU_Cyrix6x86:
strcat(name,"Cyrix 6x86 processor");
break;
case CPU_Cyrix6x86MX:
strcat(name,"Cyrix 6x86MX processor");
break;
case CPU_CyrixMediaGX:
strcat(name,"Cyrix MediaGX processor");
break;
case CPU_CyrixMediaGXm:
strcat(name,"Cyrix MediaGXm processor");
break;
case CPU_UnkCyrix:
strcat(name,"Unknown Cyrix processor");
break;
case CPU_AMDAm486:
strcat(name,"AMD Am486 processor");
break;
case CPU_AMDAm5x86:
strcat(name,"AMD Am5x86 processor");
break;
case CPU_AMDK5:
strcat(name,"AMD K5 processor");
break;
case CPU_AMDK6:
strcat(name,"AMD K6 processor");
break;
case CPU_AMDK6_2:
strcat(name,"AMD K6-2 processor");
break;
case CPU_AMDK6_III:
strcat(name,"AMD K6-III processor");
break;
case CPU_AMDK6_2plus:
strcat(name,"AMD K6-2+ processor");
break;
case CPU_AMDK6_IIIplus:
strcat(name,"AMD K6-III+ processor");
break;
case CPU_UnkAMD:
strcat(name,"Unknown AMD processor");
break;
case CPU_AMDAthlon:
strcat(name,"AMD Athlon processor");
break;
case CPU_AMDDuron:
strcat(name,"AMD Duron processor");
break;
case CPU_WinChipC6:
strcat(name,"IDT WinChip C6 processor");
break;
case CPU_WinChip2:
strcat(name,"IDT WinChip 2 processor");
break;
case CPU_UnkIDT:
strcat(name,"Unknown IDT processor");
break;
default:
strcat(name,"Unknown processor");
}
if (CPU_haveMMX())
strcat(name," with MMX(R)");
if (CPU_have3DNow())
strcat(name,", 3DNow!(R)");
if (CPU_haveSSE())
strcat(name,", SSE(R)");
return name;
#else
return "Unknown";
#endif
}
/****************************************************************************
DESCRIPTION:
Returns the type of processor in the system.
HEADER:
ztimer.h
RETURNS:
Numerical identifier for the installed processor
REMARKS:
Returns the type of processor in the system. Note that if the CPU is an
unknown Pentium family processor that we don't have an enumeration for,
the return value will be greater than or equal to the value of CPU_UnkPentium
(depending on the value returned by the CPUID instruction).
SEE ALSO:
CPU_getProcessorSpeed, CPU_haveMMX, CPU_getProcessorName
****************************************************************************/
uint ZAPI CPU_getProcessorType(void)
{
#if defined(__INTEL__)
uint cpu,vendor,model,cacheSize;
static ibool firstTime = true;
if (_CPU_haveCPUID()) {
cpu = _CPU_checkCPUID();
vendor = cpu & ~CPU_mask;
if (vendor == CPU_Intel) {
/* Check for Intel processors */
switch (cpu & CPU_mask) {
case 4: cpu = CPU_i486; break;
case 5: cpu = CPU_Pentium; break;
case 6:
if ((model = _CPU_getCPUIDModel()) == 1)
cpu = CPU_PentiumPro;
else if (model <= 6) {
cacheSize = _CPU_getCacheSize();
if ((model == 5 && cacheSize == 0) ||
(model == 5 && cacheSize == 256) ||
(model == 6 && cacheSize == 128))
cpu = CPU_Celeron;
else
cpu = CPU_PentiumII;
}
else if (model >= 7) {
/* Model 7 == Pentium III */
/* Model 8 == Celeron/Pentium III Coppermine */
cacheSize = _CPU_getCacheSize();
if ((model == 8 && cacheSize == 128))
cpu = CPU_Celeron;
else
cpu = CPU_PentiumIII;
}
break;
default:
cpu = CPU_UnkIntel;
}
}
else if (vendor == CPU_Cyrix) {
/* Check for Cyrix processors */
switch (cpu & CPU_mask) {
case 4:
if ((model = _CPU_getCPUIDModel()) == 4)
cpu = CPU_CyrixMediaGX;
else
cpu = CPU_UnkCyrix;
break;
case 5:
if ((model = _CPU_getCPUIDModel()) == 2)
cpu = CPU_Cyrix6x86;
else if (model == 4)
cpu = CPU_CyrixMediaGXm;
else
cpu = CPU_UnkCyrix;
break;
case 6:
if ((model = _CPU_getCPUIDModel()) <= 1)
cpu = CPU_Cyrix6x86MX;
else
cpu = CPU_UnkCyrix;
break;
default:
cpu = CPU_UnkCyrix;
}
}
else if (vendor == CPU_AMD) {
/* Check for AMD processors */
switch (cpu & CPU_mask) {
case 4:
if ((model = _CPU_getCPUIDModel()) == 0)
cpu = CPU_AMDAm5x86;
else
cpu = CPU_AMDAm486;
break;
case 5:
if ((model = _CPU_getCPUIDModel()) <= 3)
cpu = CPU_AMDK5;
else if (model <= 7)
cpu = CPU_AMDK6;
else if (model == 8)
cpu = CPU_AMDK6_2;
else if (model == 9)
cpu = CPU_AMDK6_III;
else if (model == 13) {
if (_CPU_getCPUIDStepping() <= 3)
cpu = CPU_AMDK6_IIIplus;
else
cpu = CPU_AMDK6_2plus;
}
else
cpu = CPU_UnkAMD;
break;
case 6:
if ((model = _CPU_getCPUIDModel()) == 3)
cpu = CPU_AMDDuron;
else
cpu = CPU_AMDAthlon;
break;
default:
cpu = CPU_UnkAMD;
}
}
else if (vendor == CPU_IDT) {
/* Check for IDT WinChip processors */
switch (cpu & CPU_mask) {
case 5:
if ((model = _CPU_getCPUIDModel()) <= 4)
cpu = CPU_WinChipC6;
else if (model == 8)
cpu = CPU_WinChip2;
else
cpu = CPU_UnkIDT;
break;
default:
cpu = CPU_UnkIDT;
}
}
else {
/* Assume a Pentium compatible Intel clone */
cpu = CPU_Pentium;
}
return cpu | vendor | (_CPU_getCPUIDStepping() << CPU_steppingShift);
}
else {
if (_CPU_check80386())
cpu = CPU_i386;
else if (_CPU_check80486()) {
/* If we get here we may have a Cyrix processor so we can try
* enabling the CPUID instruction and trying again.
*/
if (firstTime) {
firstTime = false;
_CPU_enableCyrixCPUID();
return CPU_getProcessorType();
}
cpu = CPU_i486;
}
else
cpu = CPU_Pentium;
if (!_CPU_checkClone())
return cpu | CPU_Intel;
return cpu;
}
#elif defined(__ALPHA__)
return CPU_Alpha;
#elif defined(__MIPS__)
return CPU_Mips;
#elif defined(__PPC__)
return CPU_PowerPC;
#endif
}
/****************************************************************************
DESCRIPTION:
Returns a string defining the speed and name of the processor.
HEADER:
cpuinfo.h
RETURNS:
Processor name string.
REMARKS:
This function returns an English string describing the speed and name of the
CPU.
SEE ALSO:
CPU_getProcessorType, CPU_haveMMX, CPU_getProcessorName
****************************************************************************/
char * ZAPI CPU_getProcessorName(void)
{
#if defined(__INTEL__)
static int cpu,speed = -1;
static char name[80];
if (speed == -1) {
cpu = CPU_getProcessorType();
speed = CPU_getProcessorSpeed(false);
}
if (speed >= 1000)
sprintf(name,"%d.%d GHz ", speed / 1000,((speed + 50) / 100) % 10);
else
sprintf(name,"%d MHz ", speed);
switch (cpu & CPU_mask) {
case CPU_i386:
strcat(name,"Intel i386 processor");
break;
case CPU_i486:
strcat(name,"Intel i486 processor");
break;
case CPU_Pentium:
strcat(name,"Intel Pentium processor");
break;
case CPU_PentiumPro:
strcat(name,"Intel Pentium Pro processor");
break;
case CPU_PentiumII:
strcat(name,"Intel Pentium II processor");
break;
case CPU_Celeron:
strcat(name,"Intel Celeron processor");
break;
case CPU_PentiumIII:
strcat(name,"Intel Pentium III processor");
break;
case CPU_Pentium4:
strcat(name,"Intel Pentium 4 processor");
break;
case CPU_UnkIntel:
strcat(name,"Unknown Intel processor");
break;
case CPU_UnkX86:
strcat(name,"Unknown x86 processor");
break;
case CPU_Cyrix6x86:
strcat(name,"Cyrix 6x86 processor");
break;
case CPU_Cyrix6x86MX:
strcat(name,"Cyrix 6x86MX processor");
break;
case CPU_CyrixMediaGX:
strcat(name,"Cyrix MediaGX processor");
break;
case CPU_CyrixMediaGXm:
strcat(name,"Cyrix MediaGXm processor");
break;
case CPU_UnkCyrix:
strcat(name,"Unknown Cyrix processor");
break;
case CPU_AMDAm486:
strcat(name,"AMD Am486 processor");
break;
case CPU_AMDAm5x86:
strcat(name,"AMD Am5x86 processor");
break;
case CPU_AMDK5:
strcat(name,"AMD K5 processor");
break;
case CPU_AMDK6:
strcat(name,"AMD K6 processor");
break;
case CPU_AMDK6_2:
strcat(name,"AMD K6-2 processor");
break;
case CPU_AMDK6_III:
strcat(name,"AMD K6-III processor");
break;
case CPU_AMDK6_2plus:
strcat(name,"AMD K6-2+ processor");
break;
case CPU_AMDK6_IIIplus:
strcat(name,"AMD K6-III+ processor");
break;
case CPU_UnkAMD:
strcat(name,"Unknown AMD processor");
break;
case CPU_AMDAthlon:
strcat(name,"AMD Athlon processor");
break;
case CPU_AMDDuron:
strcat(name,"AMD Duron processor");
break;
case CPU_AMDOpteron:
strcat(name,"AMD Opteron processor");
break;
case CPU_WinChipC6:
strcat(name,"IDT WinChip C6 processor");
break;
case CPU_WinChip2:
strcat(name,"IDT WinChip 2 processor");
break;
case CPU_UnkIDT:
strcat(name,"Unknown IDT processor");
break;
case CPU_ViaCyrixIII:
strcat(name,"VIA CyrixIII processor");
break;
case CPU_ViaEden:
strcat(name,"VIA Eden ESP processor");
break;
case CPU_UnkVIA:
strcat(name,"Unknown VIA processor");
break;
case CPU_GeodeGX1:
strcat(name,"Geode GX1 processor");
break;
case CPU_GeodeGX2:
strcat(name,"Geode GX2 processor");
break;
case CPU_UnkGeode:
strcat(name,"Unknown Geode processor");
break;
default:
strcat(name,"Unknown processor");
}
if (CPU_haveMMX())
strcat(name," with MMX(R)");
if (CPU_have3DNow())
strcat(name,", 3DNow!(R)");
if (CPU_haveSSE())
strcat(name,", SSE(R)");
if (CPU_haveSSE2())
strcat(name,", SSE2(R)");
return name;
#elif defined(__LINUX__)
return _CPU_getProcessorName();
#else
return "Unknown";
#endif
}
