[原理]编译器如何为不同的处理器都做出最优二元码--CPUID的秘密

echofrompat · 发表于 2005-5-12 10:58:50

by echofrompat@linuxsir
转载请勿删除上行。

前几天大家热呼呼地说到如何能知道自己的CPU是32位的还是64位的，小弟专门看了看有关CPUID的东东，在这里给大家参考：

x86的指令集现已成为工业标准，Intel的Pentium系列和AMD的Opteron等的芯片都支持这些指令集。你可能发现，其它的CPU，如VIA的C3也是支持x86指令集的。编译器，如gcc，都可以默认使用x86指令集生成可执行的二元码。这种基于x86最简指令集的二元码都可以在x86兼容的Intel,AMD或是VIA的CPU上运行。

我们知道，Pentium有的MMX和SSE这样的扩展指令器，AMD有3D!NOW，新发布的x86_64 CPU，如AMD64和EM64t，它们都在x86的指令上做了一定的扩充。问题是，如果我们使用的是一个比486更好的CPU，但跑在其上的二元码只使用486的指令器，显然不可能做到运行速度上的最优化。另外，兼容的64位机器上运行32位的二元码，在扩展了指令集的同时还使用到了新的寄存器，问题就更复杂了一些。现在，我们的目的是要让编译器在生成二元码时使用CPU的扩展功能，但不同厂家的CPU有不同的扩展指令集，二元码在使用的特定的扩展指令集后容易在不同的CPU上产生运行期的错误。这就引出了二元码可移植性的问题。

所以我们下载Linux下的rpm包时，有i386,i586,i686之分。i386只使用x86基本指令集，i586对Pentium及与其兼容的CPU做了指令集的优化，i686对Pentium Pro及与其兼容的CPU做了指令集的优化。

那么，编译器是如何知道CPU的特性，并能针对不同的CPU，生成最优的二元码呢？秘密就在于CPUID。

CPUID (central processing unit indentification)其实也是一个CPU的指令。它让OS和程序可以检测是否与CPU兼容，并根据不同的CPU，选择正确的执行路径(execution paths)，动态库。

对于EAX寄存器里定义的不同的输入参数，CPUID可以两组信息。如果EAX里存放的是0，CPUID就把生产商的信息放入EBX，ECX，和EDX三个寄存器中。如果EAX里的是1，则这三个寄存器里放入的是处理器特性的标识。

处理器生产商的信息很好说。不外于Intel, AMD, 和VIA。它们都喜欢在这里做广告，如Intel的CPU会返回"GenuineIntel"(真诚到永远!)，AMD的CPU会返回"AuthenticAMD"(值得信赖!)。

而对于用户和开发者，更重要的是处理器的功能上的特性。这些特性在EAX寄存器为1时，由CPUID指令将这些处理器特性的标识加载到EBX,ECX和EDX寄存器中。如，EDX中的bit 23指的是64位的MMX指令集，bit 25为SSE，26为SSE2。这里附上AMD64 CPU的程序指南以供大家参考：
http://www.amd.com/us-en/Process ... 82_739_7044,00.html

真相大白! gcc就是使用CPUID来检测CPU类型的， /proc/cpuinfo也是如此。Intel的编译器，icc，甚至可以生成统一的二元码，在执行器检测CPU类型，并选择优化过的程序段给于执行。

下面的是一个具体的检查CPU信息的实现：

/* small utility to extract CPU information
Used by configure to set CPU optimization levels on some operating
systems where /proc/cpuinfo is non-existent or unreliable. */
#include <stdio.h>
#include <sys/time.h>
#ifdef __MINGW32__
#include <sys/timeb.h>
void gettimeofday(struct timeval* t,void* timezone)
{ struct timeb timebuffer;
ftime( &timebuffer );
t->tv_sec=timebuffer.time;
t->tv_usec=1000*timebuffer.millitm;
}
#define MISSING_USLEEP
#define sleep(t) _sleep(1000*t);
#endif
#ifdef __BEOS__
#define usleep(t) snooze(t)
#endif
#ifdef M_UNIX
typedef long long int64_t;
#define MISSING_USLEEP
#else
#include <inttypes.h>
#endif
typedef struct cpuid_regs {
unsigned int eax;
unsigned int ebx;
unsigned int ecx;
unsigned int edx;
} cpuid_regs_t;
static cpuid_regs_t
cpuid(int func) {
cpuid_regs_t regs;
#define CPUID ".byte 0x0f, 0xa2; "
asm("push %%ebx; "
"movl %4,%%eax; " CPUID
"movl %%eax,%0; movl %%ebx,%1; movl %%ecx,%2; movl %%edx,%3; "
"pop %%ebx"
: "=m" (regs.eax), "=m" (regs.ebx), "=m" (regs.ecx), "=m" (regs.edx)
: "g" (func)
: "%eax", "%ecx", "%edx");
return regs;
}
static int64_t
rdtsc(void)
{
unsigned int i, j;
#define RDTSC ".byte 0x0f, 0x31; "
asm(RDTSC : "=a"(i), "=d"(j) : );
return ((int64_t)j<<32) + (int64_t)i;
}
static void
store32(char *d, unsigned int v)
{
d[0] = v & 0xff;
d[1] = (v >> 8) & 0xff;
d[2] = (v >> 16) & 0xff;
d[3] = (v >> 24) & 0xff;
}
int
main(int argc, char **argv)
{
cpuid_regs_t regs, regs_ext;
char idstr[13];
unsigned max_cpuid;
unsigned max_ext_cpuid;
unsigned int amd_flags;
char *model_name = "Unknown CPU";
int i;
char processor_name[49];
regs = cpuid(0);
max_cpuid = regs.eax;
/* printf("%d CPUID function codes\n", max_cpuid+1); */
store32(idstr+0, regs.ebx);
store32(idstr+4, regs.edx);
store32(idstr+8, regs.ecx);
idstr[12] = 0;
printf("vendor_id\t: %s\n", idstr);
if (strcmp(idstr, "GenuineIntel") == 0)
model_name = "Unknown Intel CPU";
else if (strcmp(idstr, "AuthenticAMD") == 0)
model_name = "Unknown AMD CPU";
regs_ext = cpuid((1<<31) + 0);
max_ext_cpuid = regs_ext.eax;
if (max_ext_cpuid >= (1<<31) + 1) {
regs_ext = cpuid((1<<31) + 1);
amd_flags = regs_ext.edx;
if (max_ext_cpuid >= (1<<31) + 4) {
for (i = 2; i <= 4; i++) {
regs_ext = cpuid((1<<31) + i);
store32(processor_name + (i-2)*16, regs_ext.eax);
store32(processor_name + (i-2)*16 + 4, regs_ext.ebx);
store32(processor_name + (i-2)*16 + 8, regs_ext.ecx);
store32(processor_name + (i-2)*16 + 12, regs_ext.edx);
}
processor_name[48] = 0;
model_name = processor_name;
}
} else {
amd_flags = 0;
}
if (max_cpuid >= 1) {
static struct {
int bit;
char *desc;;
char *description;
} cap[] = {
{ 0, "fpu", "Floating-point unit on-chip" },
{ 1, "vme", "Virtual Mode Enhancements" },
{ 2, "de", "Debugging Extension" },
{ 3, "pse", "Page Size Extension" },
{ 4, "tsc", "Time Stamp Counter" },
{ 5, "msr", "Pentium Processor MSR" },
{ 6, "pae", "Physical Address Extension" },
{ 7, "mce", "Machine Check Exception" },
{ 8, "cx8", "CMPXCHG8B Instruction Supported" },
{ 9, "apic", "On-chip CPIC Hardware Enabled" },
{ 11, "sep", "SYSENTER and SYSEXIT" },
{ 12, "mtrr", "Memory Type Range Registers" },
{ 13, "pge", "PTE Global Bit" },
{ 14, "mca", "Machine Check Architecture" },
{ 15, "cmov", "Conditional Move/Compare Instruction" },
{ 16, "pat", "Page Attribute Table" },
{ 17, "pse36", "Page Size Extension 36-bit" },
{ 18, "psn", "Processor Serial Number" },
{ 19, "cflsh", "CFLUSH instruction" },
{ 21, "ds", "Debug Store" },
{ 22, "acpi", "Thermal Monitor and Clock Ctrl" },
{ 23, "mmx", "MMX Technology" },
{ 24, "fxsr", "FXSAVE/FXRSTOR" },
{ 25, "sse", "SSE Extensions" },
{ 26, "sse2", "SSE2 Extensions" },
{ 27, "ss", "Self Snoop" },
{ 29, "tm", "Therm. Monitor" },
{ -1 }
};
static struct {
int bit;
char *desc;;
char *description;
} cap_amd[] = {
{ 22, "mmxext","MMX Technology (AMD Extensions)" },
{ 30, "3dnowext","3Dnow! Extensions" },
{ 31, "3dnow", "3Dnow!" },
{ 32, "k6_mtrr", "Memory Type Range Registers" },
{ -1 }
};
int i;
regs = cpuid(1);
printf("cpu family\t: %d\n"
"model\t\t: %d\n"
"stepping\t: %d\n" ,
(regs.eax >> 8) & 0xf,
(regs.eax >> 4) & 0xf,
regs.eax & 0xf);
printf("flags\t\t:");
for (i = 0; cap[i].bit >= 0; i++) {
if (regs.edx & (1 << cap[i].bit)) {
printf(" %s", cap[i].desc);
}
}
for (i = 0; cap_amd[i].bit >= 0; i++) {
if (amd_flags & (1 << cap_amd[i].bit)) {
printf(" %s", cap_amd[i].desc);
}
}
printf("\n");
if (regs.edx & (1 << 4)) {
int64_t tsc_start, tsc_end;
struct timeval tv_start, tv_end;
int usec_delay;
tsc_start = rdtsc();
gettimeofday(&tv_start, NULL);
#ifdef MISSING_USLEEP
sleep(1);
#else
usleep(100000);
#endif
tsc_end = rdtsc();
gettimeofday(&tv_end, NULL);
usec_delay = 1000000 * (tv_end.tv_sec - tv_start.tv_sec)
+ (tv_end.tv_usec - tv_start.tv_usec);
printf("cpu MHz\t\t: %.3f\n",
(double)(tsc_end-tsc_start) / usec_delay);
}
}
printf("model name\t: %s\n", model_name);
exit(0);
}

复制代码

7dehao · 发表于 2005-5-12 11:04:36

多多益善！最好解释一下源代码。

echofrompat · 发表于 2005-5-12 11:11:40

原码并不难懂，只是在C里加了些汇编代码。如果大家需要解释其中的一段，请回帖告知。

mopz0506 · 发表于 2005-5-12 14:21:47

echofrompat 谈到二进码的问题，还提供了代码，大家看过以后应该比较清楚了。

不过 Redhat 声称 Fedora Core 是 P4 优化的，但它在 Athlon、Athlon XP 和 Pentium M 这样的 CPU 上也可以运行，那又是什么意思呢？

其实，象 Athlon XP 和 P4 这样的现代 CPU，为了提高运行速度，内部采用了多发射、乱序执行、超标量、流水线等各种措施。虽然支持的指令集大致相同，但是由于内部的微体系结构设计的差异，执行相同的代码，效能上可能会有相当大的差异。举个例子说，你有两行代码

z = x + y;
p = m + n;

复制代码

CPU 就可能把这两行无关的代码同时执行。再比如，

z = x + y;
if (z > 0)
then z = z + 1;
else z = z - 1;

复制代码

这时候虽然看起来 z 不计算出来是无法继续的，但是 CPU 有可能在内部把 z >0 和 z < 0 两种情况同时执行，等 z = x + y 计算完成以后，根据情况直接挑正确的结果。

做同一件事情的两种方法，可能一种对 P4 有利些，另一种对 AMD64 有利些。所以这就涉及到一个指令调度的概念。有些特殊的程序，用 Intel 自己的 icc 编译器生成的二进制代码，效能可能是 gcc 的好几倍。好在 gcc4 一出，这方面应该会来个大跃进。

而 P4 本身的设计，强调的是跑高频，特点是理论峰值高，但是对优化特别敏感。一不小心就写出效能极差的代码，99% 的程序员又是烂程序员，所以不容易发挥出来。目前由于工艺的原因，Intel 在频率提升上遇到了很大的困难，导致性能落后，发热量巨大，动辄 100 多瓦，十分恐怖。这方面 AMD 的 AMD64 系列做得更加均衡，对编译器要求不高，功耗也小。

echofrompat · 发表于 2005-5-12 15:11:02

感谢mopz0506兄的补充，讲的太好了。
机器里，寄存器的存取速度仅次于CPU的运算速度。所以寄存器的多少和它与逻辑运算单元的并行关系也就成为了优化二元码的重点。
SSE是SIMD的扩展，它可以允许CPU在一个指令中同时完成多个运算，如，
z = x + y;
p = m + n;
这样的两个加法运算，在支持SSE的CPU中就能用一个指令完成。SSE2还可以将两个乘除法运算用一条指令完成。但如果只用x86的指令集就没有这种好处。
这样，编译器在优化二元码时就会把可以并行的指令并行起来，使它们在运行得更快。

所以，程序在编写的时候，看起来是串行的，但实际经过优化的二元码却是串行的。
P4的优点是超线程做得非常强，它的流水线达到了21条(忘记是21还是23了)，这样，寄存器就会频繁的读写，来和逻辑运算器并行。经过icc优化的代码可以很好地利用P4的这一有利优势。
但这又带出了一个新问题：程序中除了并行部分，还有很多其它execution path，也就是在执行期由于循环，判断等产生的跳转。如果编译器处理不当，这种跳转在P4这样超线程极强的CPU上会带来严重的性能影响。因为一个跳转有可能会使超线程中的指令在并行过程中执行的取消，而这些指令都是已装载好寄存器的。它们被取消后，寄存器不得不重新装载，这些就会带来性能问题。
P3和Centrino的超线程流水线只有7条，在这方面可以很好地达到一个平衡点。AMD的CPU在这方面与P3也很相似。
这让我想起了一句话： When something is really good, then it's really bad

mopz0506 · 发表于 2005-5-12 15:51:57

感觉你说的不大对，不过也没什么大关系啦。

P4 有两代，老的 Northwood 核心和新的 Prescott 核心，同属 Netburst 体系结构。流水线长度有所不同，同一核心的，整数和浮点也不同。

Netburst 采用了大量的先进理念和技术，但实际当中效果很不好。基本上，Intel 现在已经承认 Netburst 没有前途，未来的 CPU 将基于全新架构，这个架构跟 P-M 亲缘关系更近一点。

所以目前买笔记本要买 Intel 的，买桌面电脑应当买 AMD 的，呵呵。好在我有先见之明，用的是 Athlon XP。

喜欢这方面的可以去 http://www.sandpile.org/ 看看，有非常详实的 CPU 资料。

echofrompat · 发表于 2005-5-12 16:53:29

嗯，我的经验不足，如有错误，请大家指正，先谢谢了!

AMD-K6 · 发表于 2005-5-12 20:51:35

收藏!感谢 echofrompat 兄弟的辛苦工作(最好将这个帖子转到程序版块下)

7dehao · 发表于 2005-5-13 07:03:42

Post by AMD-K6
收藏!感谢 echofrompat 兄弟的辛苦工作(最好将这个帖子转到程序版块下)

程序版块的帖子应该将精力集中于如何编程。而该贴是讨论linux工作原理的，因此还是放在基础版最为适宜。

		自动登录	找回密码
密码			注册

[原理]编译器如何为不同的处理器都做出最优二元码--CPUID的秘密

浏览过的版块