请教一CPU有关的知识

CPU又叫中央处理器，是英文单词Central Processing Unit的缩写，负责对信息和数据进行运算和处理，并实现本身运行过程的自动化。在早期的计算机当中，CPU被分成了运算器和控 制器两个部分，后来由于电路集成度的提高，在微处理器问世时，就将它们都集成在一个芯片中了。需要智能控制、大量信息处理的地方就会 用到CPU。

CPU有通用CPU和嵌入式CPU，通用和嵌入式的分别，主要是根据应用模式的不同而划分的。通用CPU芯片的功能一般比较强，能运 行复杂的 *** 作系统和大型应用软件。嵌入式CPU在功能和性能上有很大的变化范围。随着集成度的提高，在嵌入式应用中，人们倾向于把CPU、 存储器和一些外围电路集成到一个芯片上，构成所谓的系统芯片（简称为SOC），而把SOC上的那个CPU成为CPU芯核。

现在，指令系统的优化设计有两个截然相反的方向。一个是增强指令的功能,设置一些功能复杂的指令，把一些原来有软件实现的常用功能 改用硬件的指令系统来实现，这种计算机成为复杂指令系统计算机。早期Intel的X86指令体系就是一种CISC指令结构。

RISC是Reduced Instruction Set Computer的缩写中文翻译成精简指令系统计算机，是八十年代发展起来的，尽量简化指令功能，只保留那些功能简单，能在 一个节拍内执行完成的指令，较复杂的功能用一段子程序来实现，这种计算机系统成为精简指令系统计算机。目前采用RISC体系结构的处理器 的芯片厂商有SUN、SGI、IBM的Power PC系列、DEC公司的Alpha系列、Motorola公司的龙珠和Power PC等等。

介绍一下 MIPS体系。

MIPS是世界上很流行的一种RISC处理器。MIPS的意思是"无内部互锁流水级的微处理器"(Microprocessor without interlocked piped stages)，其机制是尽量利用软件办法避免流水线中的数据相关问题。他最早是在80年代初期由斯坦福（Stanford）大学 Hennessy教授领导的研究小组研制出来的。MIPS公司的R系列就是在此基础上开发的RISC工业产品的微处理器。这些系列产品以为很多打计算机 公司采用构成各种工作站和计算机系统。

指令系统

要讲CPU，就必须先讲一下指令系统。 指令系统指的是一个CPU所能够处理的全部指

令的集合，是一个CPU的根本属性。比如我们现在所用的CPU都是采用x86指令集的，他们都是 同一类型的CPU，不管是PIII、Athlon或Joshua。我们也知道，世界上还有比PIII和Athlon快得多的CPU，比如Alpha，但它们不是用x86指令集 ，不能使用数量庞大的基于x86指令集的程序，如Windows98。之所以说指令系统是一个CPU的根本属性，是因为指令系统决定了一个CPU能够运 行什么样的程序。

所有采用高级语言编出的程序，都需要翻译（编译或解释）成为机器语言后才能运行，这些机器语言中 所包含的就是一条条的指令。

1、 指令的格式

一条指令一般包括两个部分： *** 作码和地址码。 *** 作码其实就是指令序列号，用来告诉CPU需要执行的是那一条指令。地址码则复杂一些，主要包括源 *** 作数地址、目的地址和下一条指令的地址 。在某些指令中，地址码可以部分或全部省略，比如一条空指令就只有 *** 作码而没有地址码。

举个例子吧，某个指令系统 的指令长度为32位， *** 作码长度为8位，地址长度也为8位，且第一条指令是加，第二条指令是减。当它收到一个 “00000010000001000000000100000110”的指令时，先取出它的前8位 *** 作码，即00000010，分析得出这是一个减法 *** 作，有3个地址，分别是 两个源 *** 作数地址和一个目的地址。于是，CPU就到内存地址00000100处取出被减数，到00000001处取出减数，送到ALU中进行减法运算，然后 把结果送到00000110处。

这只是一个相当简单化的例子，实际情况要复杂的多

2、 指令的分类与寻址 方式

一般说来，现在的指令系统有以下几种类型的指令：

（1）算术逻辑运算指令

算术逻辑运算 指令包括加减乘除等算术运算指令，以及与或非异或等逻辑运算指令。现在的指令系统还加入了一些十进制运算指令以及字符串运算指令等。

（2）浮点运算指令

用于对浮点数进行运算。浮点运算要大大复杂于整数运算，所以CPU中一般还会有专门负责浮点运 算的浮点运算单元。现在的浮点指令中一般还加入了向量指令，用于直接对矩阵进行运算，对于现在的多媒体和3D处理很有用。

（3）位 *** 作指令

学过C的人应该都知道C语言中有一组位 *** 作语句，相对应的，指令系统中也有一组位 *** 作指令，如左移一位右移 一位等。对于计算机内部以二进制不码表示的数据来说，这种 *** 作是非常简单快捷的。

（4）其他指令

上面三种都是 运算型指令，除此之外还有许多非运算的其他指令。这些指令包括：数据传送指令、堆栈 *** 作指令、转移类指令、输入输出指令和一些比较特 殊的指令，如特权指令、多处理器控制指令和等待、停机、空 *** 作等指令。

对于指令中的地址码，也会有许多不同的寻址 （编址）方式，主要有直接寻址，间接寻址，寄存器寻址，基址寻址，变址寻址等，某些复杂的指令系统会有几十种甚至更多的寻址方式。

3、 CISC与RISC

CISC，Complex Instruction Set Computer，复杂指令系统计算机。RISC，Reduced Instruction Set Computer，精简指令系统计算机。虽然这两个名词是针对计算机的，但下文我们仍然只对指令集进行研究。

（1）CISC 的产生、发展和现状

一开始，计算机的指令系统只有很少一些基本指令，而其他的复杂指令全靠软件编译时通过简单指令 的组合来实现。举个最简单的例子，一个a乘以b的 *** 作就可以转换为a个b相加来做，这样就用不着乘法指令了。当然，最早的指令系统就已经 有乘法指令了，这是为什么呢？因为用硬件实现乘法比加法组合来得快得多。

由于那时的计算机部件相当昂贵，而且速度 很慢，为了提高速度，越来越多的复杂指令被加入了指令系统中。但是，很快又有一个问题：一个指令系统的指令数是受指令 *** 作码的位数所 限制的，如果 *** 作码为8位，那么指令数最多为256条（2的8次方）。

那么怎么办呢？指令的宽度是很难增加的，聪明的设计师们又想出了 一种方案： *** 作码扩展。前面说过， *** 作码的后面跟的是地址码，而有些指令是用不着地址码或只用少量的地址码的。那么，就可以把 *** 作码 扩展到这些位置。

举个简单的例子，如果一个指令系统的 *** 作码为2位，那么可以有00、01、10、11四条不同的指令。现在 把11作为保留，把 *** 作码扩展到4位，那么就可以有00、01、10、1100、1101、1110、1111七条指令。其中1100、1101、1110、1111这四条指令 的地址码必须少两位。

然后，为了达到 *** 作码扩展的先决条件：减少地址码，设计师们又动足了脑筋，发明了各种各样的寻址方式，如基 址寻址、相对寻址等，用以最大限度的压缩地址码长度，为 *** 作码留出空间。

就这样，慢慢地，CISC指令系统就形成了， 大量的复杂指令、可变的指令长度、多种的寻址方式是CISC的特点，也是CISC的缺点：因为这些都大大增加了解码的难度，而在现在的高速硬 件发展下，复杂指令所带来的速度提升早已不及在解码上浪费点的时间。除了个人PC市场还在用x86指令集外，服务器以及更大的系统都早已不 用CISC了。x86仍然存在的唯一理由就是为了兼容大量的x86平台上的软件。

]：（2）RISC的产生、发展和现状

1975年，IBM的设计师John Cocke研究了当时的IBM370CISC系统，发现其中占总指令数仅20%的简单指令却在程序调用中占了80% ，而占指令数80%的复杂指令却只有20%的机会用到。由此，他提出了RISC的概念。

事实证明，RISC是成功的。80年代末，各公司的RISC CPU如雨后春笋般大量出现，占据了大量的市场。到了90年代，x86的CPU如pentium和k5也开始使用先进的RISC核心。

RISC 的最大特点是指令长度固定，指令格式种类少，寻址方式种类少，大多数是简单指令且都能在一个时钟周期内完成，易于设计超标量与流水线 ，寄存器数量多，大量 *** 作在寄存器之间进行。由于下文所讲的CPU核心大部分是讲RISC核心，所以这里就不多介绍了，对于RISC核心的设计下 面会详细谈到。

RISC目前正如日中天，Intel的Itanium也将最终抛弃x86而转向RISC结构。

二、CPU内核结构

好吧 ，下面来看看CPU。CPU内核主要分为两部分：运算器和控制器。

（一） 运算器

1、 算术逻辑运算单元ALU（Arithmetic and Logic Unit）

ALU主要完成对二进制数据的定点算术运算（加减乘除）、逻辑运算（与或非异或）以及移位 *** 作。在某些CPU中还 有专门用于处理移位 *** 作的移位器。

通常ALU由两个输入端和一个输出端。整数单元有时也称为IEU（Integer Execution Unit）。我们通常所说的“CPU是XX位的”就是指ALU所能处理的数据的位数。

2、 浮点运算单元FPU（Floating Point Unit）

FPU主要负责浮点运算和高精度整数运算。有些FPU还具有向量运算的功能，另外一些则有专门的向量处理单元。

3、通用寄存器组

通用寄存器组是一组最快的存储器，用来保存参加运算的 *** 作数和中间结果。

在通用寄存器的设计上，RISC与CISC有 着很大的不同。CISC的寄存器通常很少，主要是受了当时硬件成本所限。比如x86指令集只有8个通用寄存器。所以，CISC的CPU执行是大多数时 间是在访问存储器中的数据，而不是寄存器中的。这就拖慢了整个系统的速度。而RISC系统往往具有非常多的通用寄存器，并采用了重叠寄存 器窗口和寄存器堆等技术使寄存器资源得到充分的利用。

对于x86指令集只支持8个通用寄存器的缺点，Intel和AMD的最新 CPU都采用了一种叫做“寄存器重命名”的技术，这种技术使x86CPU的寄存器可以突破8个的限制，达到32个甚至更多。不过，相对于RISC来说 ，这种技术的寄存器 *** 作要多出一个时钟周期，用来对寄存器进行重命名。

4、 专用寄存器

专用寄存器通常是一些状 态寄存器，不能通过程序改变，由CPU自己控制，表明某种状态。

（二） 控制器

运算器只能完成运算，而控 制器用于控制着整个CPU的工作。

1、 指令控制器

指令控制器是控制器中相当重要的部分，它要完成取指令、分析指令等 *** 作，然 后交给执行单元（ALU或FPU）来执行，同时还要形成下一条指令的地址。

2、 时序控制器

时序控制器的作用是为每条 指令按时间顺序提供控制信号。时序控制器包括时钟发生器和倍频定义单元，其中时钟发生器由石英晶体振荡器发出非常稳定的脉冲信号，就 是CPU的主频；而倍频定义单元则定义了CPU主频是存储器频率（总线频率）的几倍。

3、 总线控制器

总线控制器主要用于控制CPU 的内外部总线，包括地址总线、数据总线、控制总线等等。

4、中断控制器

中断控制器用于控制各种各样的中断请求，并根据优先 级的高低对中断请求进行排队，逐个交给CPU处理。

（三） CPU核心的设计

CPU的性能是由什么决定的呢？单纯的一个ALU速度在一个CPU中并不起决定性作用，因为ALU的速度都差不多。而一个CPU的性能表现的决 定性因素就在于CPU内核的设计。

1、超标量（Superscalar）

既然无法大幅提高ALU的速度，有什么替代的方法呢？并行处理的方 法又一次产生了强大的作用。所谓的超标量CPU，就是只集成了多个ALU、多个FPU、多个译码器和多条流水线的CPU，以并行处理的方式来提高 性能。

超标量技术应该是很容易理解的，不过有一点需要注意，就是不要去管“超标量”之前的那个数字，比如“9路超标量”，不同 的厂商对于这个数字有着不同的定义，更多的这只是一种商业上的宣传手段。

2、流水线（Pipeline）

流水线是现代RISC核心的一 个重要设计，它极大地提高了性能。

对于一条具体的指令执行过程，通常可以分为五个部分：取指令，指令译码，取 *** 作数，运算 （ALU），写结果。其中前三步一般由指令控制器完成，后两步则由运算器完成。按照传统的方式，所有指令顺序执行，那么先是指令控制器工 作，完成第一条指令的前三步，然后运算器工作，完成后两步，在指令控制器工作，完成第二条指令的前三步，在是运算器，完成第二条指令 的后两部……很明显，当指令控制器工作是运算器基本上在休息，而当运算器在工作时指令控制器却在休息，造成了相当大的资源浪费。解决 方法很容易想到，当指令控制器完成了第一条指令的前三步后，直接开始第二条指令的 *** 作，运算单元也是。这样就形成了流水线系统，这是 一条2级流水线。

如果是一个超标量系统，假设有三个指令控制单元和两个运算单元，那么就可以在完成了第一条指令的取址工作后直 接开始第二条指令的取址，这时第一条指令在进行译码，然后第三条指令取址，第二条指令译码，第一条指令取 *** 作数……这样就是一个5级流 水线。很显然，5级流水线的平均理论速度是不用流水线的4倍。

流水线系统最大限度地利用了CPU资源，使每个部件在每个时钟周期都 工作，大大提高了效率。但是，流水线有两个非常大的问题：相关和转移。

在一个流水线系统中，如果第二条指令需要用到第一条指 令的结果，这种情况叫做相关。以上面哪个5级流水线为例，当第二条指令需要取 *** 作数时，第一条指令的运算还没有完成，如果这时第二条指 令就去取 *** 作数，就会得到错误的结果。所以，这时整条流水线不得不停顿下来，等待第一条指令的完成。这是很讨厌的问题，特别是对于比 较长的流水线，比如20级，这种停顿通常要损失十几个时钟周期。目前解决这个问题的方法是乱序执行。乱序执行的原理是在两条相关指令中 插入不相关的指令，使整条流水线顺畅。比如上面的例子中，开始执行第一条指令后直接开始执行第三条指令（假设第三条指令不相关），然 后才开始执行第二条指令，这样当第二条指令需要取 *** 作数时第一条指令刚好完成，而且第三条指令也快要完成了，整条流水线不会停顿。当 然，流水线的阻塞现象还是不能完全避免的，尤其是当相关指令非常多的时候。

另一个大问题是条件转移。在上面的例子中，如果第 一条指令是一个条件转移指令，那么系统就会不清楚下面应该执行那一条指令？这时就必须等第一条指令的判断结果出来才能执行第二条指令 。条件转移所造成的流水线停顿甚至比相关还要严重的多。所以，现在采用分支预测技术来处理转移问题。虽然我们的程序中充满着分支，而 且哪一条分支都是有可能的，但大多数情况下总是选择某一分支。比如一个循环的末尾是一个分支，除了最后一次我们需要跳出循环外，其他 的时候我们总是选择继续循环这条分支。根据这些原理，分支预测技术可以在没有得到结果之前预测下一条指令是什么，并执行它。现在的分 支预测技术能够达到90%以上的正确率，但是，一旦预测错误，CPU仍然不得不清理整条流水线并回到分支点。这将损失大量的时钟周期。所以 ，进一步提高分支预测的准确率也是正在研究的一个课题。

越是长的流水线，相关和转移两大问题也越严重，所以，流水线并不是越 长越好，超标量也不是越多越好，找到一个速度与效率的平衡点才是最重要的。

1、解码器（Decode Unit）

这是x86CPU才有的东西，它的作用是把长度不定的x86指令转换为长度固定的类似于RISC的指令，并交给RISC内核。解码分为硬件解码和微解码 ，对于简单的x86指令只要硬件解码即可，速度较快，而遇到复杂的x86指令则需要进行微解码，并把它分成若干条简单指令，速度较慢且很复 杂。好在这些复杂指令很少会用到。

Athlon也好，PIII也好，老式的CISC的x86指令集严重制约了他们的性能表现。

2、一级缓存 和二级缓存（Cache）

以及缓存和二级缓存是为了缓解较快的CPU与较慢的存储器之间的矛盾而产生的，以及缓存通常集成在CPU内核， 而二级缓存则是以OnDie或OnBoard的方式以较快于存储器的速度运行。对于一些大数据交换量的工作，CPU的Cache显得尤为重要。

译内核，属于软件部分．

内核是 *** 作系统的内部核心程序，它向外部提供了对计算机设备的核心管理调用。我们将 *** 作系统的代码分成2部分。内核所在的地址空间称作内核空间。而在内核以外的统称为外部管理程序，它们大部分是对外围设备的管理和界面 *** 作。外部管理程序与用户进程所占据的地址空间称为外部空间。通常，一个程序会跨越两个空间。当执行到内河空间的一段代码时，我们称程序处于内核态，而当程序执行到外部空间代码时，我们称程序处于用户态。

从UNIX起，人们开始用高级语言（UNIX上最具有代表性的就是UNIX的系统级语言C语言）编写内核代码，使得内核具有良好的扩展性。单一内核（monolithic kernel）是当时 *** 作系统的主流， *** 作系统中所有的系统相关功能都被封装在内核中，它们与外部程序处于不同的内存地址空间中，并通过各种方式（在Intel IA－32体系中采用386保护模式）防止 外部程序直接访问内核结构。程序只有通过一套称作系统调用（system call）的界面访问内核结构。近些年来，微内核（micro kernel）结构逐渐流行起来，成为 *** 作系统的主要潮流。1986年，Tanenbaum提出Mach kernel，而后，他的minix和GNU的Hurd *** 作系统更是微内核系统的典范。

在微内核结构中， *** 作系统的内核只需要提供最基本、最核心的一部分 *** 作（比如创建和删除任务、内存管理、中断管理等）即可，而其他的管理程序（如文件系统、网络协议栈等）则尽可能的放在内核之外。这些外部程序可以独立运行，并对外部用户程序提供 *** 作系统服务，服务之间使用进程间通信机制（IPC）进行交互，只在需要内核的协助时，才通过一套接口对内核发出调用请求。

微内核系统的优点时 *** 作系统具有良好的灵活性。它使得 *** 作系统内部结构简单清晰。程序代码的维护非常之方便。但是也有不足之处。微内核系统由于核心态只实现了最基本的系统 *** 作，这样内核以外的外部程序之间由于独立运行使得系统难以进行良好的整体优化。另外，进程间互相通信的开销也较单一内核系统要大许多。从整体上看，在当前的硬件条件下，微内核在效率上的损失小于其在结构上获得的收益，故而选取微内核成为 *** 作系统的一大潮流。

然而，Linux系统却恰恰使用了单一内核结构。这是由于Linux是一个实用主义的 *** 作系统。Linux Tovarlds以代码执行效率为自己 *** 作系统的第一要务，并没有进行过一个系统的设计工作，而是任由Linux在使用中不断发展。在这样的发展过程中，参与Linux开发的程序员大多为世界各地的黑客们。比起结构的清晰，他们更加注重功能的强大和高效的代码。于是，他们将大量的精力放在优化代码上，而这样的全局性优化必然以丧失结构精简为代价，导致Linux中的每个部件都不能轻易被拆除。否则必然破坏整体效率。

虽然Linux是单一内核体系，但是它与传统的单一内核UNIX *** 作系统不同。在普通的单一内核系统中，所有的内核代码都是被静态编译联入的，而在Linux中，可以动态装入和卸载内河中的部分代码。Linux将这些代码段称为模块。（module），并对模块给予了强有力的支持。在Linux中，可以在需要时自动装入和卸载模块。

Linux不支持用户态线程。在用户态中，Linux认为线程就是共享上下文（Context）的进程。Linux通过LWP（light weight thread）的机制来实现用户态线程的概念。通过系统调用clone（）创建新的线程。

Linux的内核为非抢占式的。即，Linux不能通过改变优先权来影响内核当前的执行流程。因此，Linux在实现实时 *** 作时就有问题。Linux并不是一个“硬”实时 *** 作系统。

在Linux内核中，包括了进程管理（process management）、定时器（timer）、中断管理（interrupt management）、内存管理（memory management）、模块管理（module management）、虚拟文件系统接口（VFS layer）、文件系统（file system）、设备驱动程序（device driver）、进程间通信（inter-process communication）、网络管理（network management）、系统启动（system init）等 *** 作系统功能的实现。

2、另一种便是硬件内核了，很多硬件都是有内核的．不过大体还是和软内核相联系，我这里简单的说一种内核吧．

核心（Die）又称为内核，是CPU最重要的组成部分。CPU中心那块隆起的芯片就是核心，是由单晶硅以一定的生产工艺制造出来的，CPU所有的计算、接受/存储命令、处理数据都由核心执行。各种CPU核心都具有固定的逻辑结构，一级缓存、二级缓存、执行单元、指令级单元和总线接口等逻辑单元都会有科学的布局。

为了便于CPU设计、生产、销售的管理，CPU制造商会对各种CPU核心给出相应的代号，这也就是所谓的CPU核心类型。

不同的CPU（不同系列或同一系列）都会有不同的核心类型（例如Pentium 4的Northwood，Willamette以及K6-2的CXT和K6-2+的ST-50等等），甚至同一种核心都会有不同版本的类型（例如Northwood核心就分为B0和C1 等版本），核心版本的变更是为了修正上一版存在的一些错误，并提升一定的性能，而这些变化普通消费者是很少去注意的。每一种核心 类型都有其相应的制造工艺（例如025um、018um、013um以及009um等）、核心面积（这是决定CPU 成本的关键因素，成本与核心面积基本上成正比）、核心电压、电流大小、晶体管数量、各级缓存的大小、主频范围、流水线架构和支持 的指令集（这两点是决定CPU实际性能和工作效率的关键因素）、功耗和发热量的大小、封装方式（例如SEP、PGA、FC-PGA、FC-PGA2等等）、接口类型（例如Socket 370，Socket A，Socket 478，Socket T，Slot 1、Socket 940等等）、前端总线频率（FSB）等等。因此，核心类型在某种程度上决定了CPU的工作性能。

一般说来，新的核心类型往往比老的核心类型具有更好的性能（例如同频的Northwood核心Pentium 4 18A GHz就要比Willamette核心的Pentium 4 18GHz 性能要高），但这也不是绝对的，这种情况一般发生在新核心类型刚推出时，由于技术不完善或新的架构和制造工艺不成熟等原因，可能 会导致新的核心类型的性能反而还不如老的核心类型的性能。例如，早期 Willamette核心Socket 423接口的Pentium 4的实际性能不如Socket 370接口的Tualatin核心的Pentium III和赛扬，现在的低频Prescott核心Pentium 4的实际性能不如同频的Northwood核心Pentium 4等等，但随着技术的进步以及CPU制造商对新核心的不断改进和完善，新核心的中后期产品的性能必然会超越老核心产品。

CPU核心的发展方向是更低的电压、更低的功耗、更先进的制造工艺、集成更多的晶体管、更小的核心面积（这会降低CPU的生产成本从而最终会降低CPU 的销售价格）、更先进的流水线架构和更多的指令集、更高的前端总线频率、集成更多的功能（例如集成内存控制器等等）以及双核心和 多核心（也就是1个CPU内部有2个或更多个核心）等。CPU核心的进步对普通消费者而言，最有意义的就是能以更低的价格买到性能更强的CPU。

在CPU漫长的历史中伴随着纷繁复杂的CPU核心类型，以下分别就Intel CPU和AMD CPU的主流核心类型作一个简介。主流核心类型介绍（仅限于台式机CPU，不包括笔记本CPU和服务器/工作站CPU，而且不包括比较老的核心类型）。

Intel CPU的核心类型 :

Tualatin

这也就是大名鼎鼎的“图拉丁”核心，是Intel在Socket 370架构上的最后一种CPU核心，采用013um制造工艺，封装方式采用FC-PGA2和PPGA，核心电压也降低到了15V左右，主频范围从1GHz到14GHz，外频分别为100MHz（赛扬）和133MHz（Pentium III），二级缓存分别为512KB（Pentium III-S）和256KB（Pentium III和赛扬），这是最强的Socket 370核心，其性能甚至超过了早期低频的Pentium 4系列CPU。

Willamette

这是早期的Pentium 4和P4赛扬采用的核心，最初采用Socket 423接口，后来改用Socket 478接口（赛扬只有17GHz和18GHz两种，都是Socket 478接口），采用018um制造工艺，前端总线频率为400MHz， 主频范围从13GHz到20GHz（Socket 423）和16GHz到20GHz（Socket 478），二级缓存分别为256KB（Pentium 4）和128KB（赛扬），注意，另外还有些型号的Socket 423接口的Pentium 4居然没有二级缓存！核心电压175V左右，封装方式采用Socket 423的PPGA INT2，PPGA INT3，OOI 423-pin，PPGA FC-PGA2和Socket 478的PPGA FC-PGA2以及赛扬采用的PPGA等等。Willamette核心制造工艺落后，发热量大，性能低下，已经被淘汰掉，而被Northwood核心所取代。

Northwood

这是目前主流的Pentium 4和赛扬所采用的核心，其与Willamette核心最大的改进是采用了013um制造工艺，并都采用Socket 478接口，核心电压15V左右，二级缓存分别为128KB（赛扬）和512KB（Pentium 4），前端总线频率分别为400/533/800MHz（赛扬都只有400MHz），主频范围分别为20GHz到28GHz（赛扬），16GHz到26GHz（400MHz FSB Pentium 4），226GHz到306GHz（533MHz FSB Pentium 4）和24GHz到34GHz（800MHz FSB Pentium 4），并且306GHz Pentium 4和所有的800MHz Pentium 4都支持超线程技术（Hyper-Threading Technology），封装方式采用PPGA FC-PGA2和PPGA。按照Intel的规划，Northwood核心会很快被Prescott核心所取代。

Prescott

这是Intel最新的CPU核心，目前还只有Pentium 4而没有低端的赛扬采用，其与Northwood最大的区别是采用了009um制造工艺和更多的流水线结构，初期采用Socket 478接口，以后会全部转到LGA 775接口，核心电压125-1525V，前端总线频率为533MHz（不支持超线程技术）和800MHz（支持超线程技术），主频分别为533MHz FSB的24GHz和28GHz以及800MHz FSB的28GHz、30GHz、32GHz和34GHz，其与Northwood相比，其L1 数据缓存从8KB增加到16KB，而L2缓存则从512KB增加到1MB，封装方式采用PPGA。按照Intel的规划，Prescott核心会很快取代Northwood核心并且很快就会推出Prescott核心533MHz FSB的赛扬。

AMD CPU的核心类型:

Athlon XP的核心类型

Athlon XP有4种不同的核心类型，但都有共同之处：都采用Socket A接口而且都采用PR标称值标注。

Palomino

这是最早的Athlon XP的核心，采用018um制造工艺，核心电压为175V左右，二级缓存为256KB，封装方式采用OPGA，前端总线频率为266MHz。

Thoroughbred

这是第一种采用013um制造工艺的Athlon XP核心，又分为Thoroughbred-A和Thoroughbred-B两种版本，核心电压165V-175V左右，二级缓存为256KB，封装方式采用OPGA，前端总线频率为266MHz和333MHz。

Thorton

采用013um制造工艺，核心电压165V左右，二级缓存为256KB，封装方式采用OPGA，前端总线频率为333MHz。可以看作是屏蔽了一半二级缓存的Barton。

Barton

采用013um制造工艺，核心电压165V左右，二级缓存为512KB，封装方式采用OPGA，前端总线频率为333MHz和400MHz。

新Duron的核心类型

AppleBred

采用013um制造工艺，核心电压15V左右，二级缓存为64KB，封装方式采用OPGA，前端总线频率为266MHz。没有采用PR标称值标注而以实际频率标注，有14GHz、16GHz和18GHz三种。

Athlon 64系列CPU的核心类型

Clawhammer

采用013um制造工艺，核心电压15V左右，二级缓存为1MB，封装方式采用mPGA，采用Hyper Transport总线，内置1个128bit的内存控制器。采用Socket 754、Socket 940和Socket 939接口。

Newcastle

其与Clawhammer的最主要区别就是二级缓存降为512KB（这也是AMD为了市场需要和加快推广64位CPU而采取的相对低价政策的结果），其它性能基本相同。

至于CPU最强的内核，在笔记本方面， Dothan 是当前最强的内核，而台式电脑方面，Intel Prescott是很强的内核，AMD Athlon 64系列CPU的核心类型Clawhammer、Newcastle也很强。

上面都是网上找的，你有空也可多看看别人的资料．

祝福大家新年快乐！！！！

使用定时器，但不使用定时器中断，很有意思的一种定时方案。时间计算是对的，4000250=1000000 ,12M下刚好是1秒。可惜没注意检查TF0标志，导致处理秒计数过快，小改了一下，就好了。下图是监视m的效果

#include <intrinsh>

#define uchar unsigned char

#define uint  unsigned int

sbit bee=P3^5;

#define  LED P0  

sbit sck=P2^7;//

sbit tck=P2^6;//

sbit data1=P2^5;//

sbit key1=P1^5;

sbit key2=P1^6;

sbit key3=P1^7;

sbit key4=P3^3;

char code led[]={0xfc,0x60,0xda,0xf2,

0x66,0xb6,0xbe,0xe0,

   0xfe,0xe6};

char code position[]={0xfe,0xfd,0xfb,0xf7,

 0xef,0xdf

                          };

void timer0();

void send(uchar data8)

{ uchar i;

  sck=1;

  tck=1;

  for(i=0;i<=7;i++)

  {if((data8>>i)&0x01)

    data1=1;

else

data1=0;

sck=0;

sck=1;}

tck=0;

tck=1; }

uchar a=0,b=0,c=0,d=0,e=0,f=0,m=0;

main()

{  

   TMOD=0X01;

   EA=1;

   EX1=1;

   IT1=1;

   TH0=(65536-4000)/256;

   TL0=(65536-4000)%256;

   TR0=1;

   while(1)

   { P0=position[0];

     send(led[a]);

 timer0();

 P0=position[1];

     send(led[b]);

 timer0();

    P0=position[2];

     send(led[c]);

 timer0();

    P0=position[3];

     send(led[d]);

 timer0();

    P0=position[4];

     send(led[e]);

 timer0();

    P0=position[5];

     send(led[f]);

 timer0();}}

void timer0()

{ 

 if(TF0){ 

 TR0=0;

  TH0+=(65536-4000+13)/256;

  TL0+=(65536-4000+13)%256;

 if(TL0<((65536-4000+13)%256))TH0+=1;

 TR0=1;

 TF0=0;

  m=m+1;

  if(m==250)

  {a=a+1;

    m=0;}

  if(a==10)

  {b=b+1;

    a=0;}

  if(b==7)

  {c=c+1;

    b=0;}

  if(c==10)

  {d=d+1;

    c=0;}

  if(d==7)

  {e=e+1;

    d=0;}

  if(e==10)

  {f=f+1;

    e=0;}

  // TR0=1;

 }

}

void int1()interrupt 2

{ while(key1!=0)

  {if(key2==0)

    { c++;}

  if(key3==0)

{ e++;}}}

我有个表的程序先给你吧

#include<reg51h>

#include<intrinsh>

#define uchar unsigned char

#define uint unsigned int

uchar isLeapYear(uint y);

sbit K1=P3^5;

sbit K2=P3^6;

sbit K3=P3^7;

sbit SDA=P1^0;

sbit CLK=P1^1;

sbit RST=P1^2;

sbit P2_0=P2^0;

sbit P2_1=P2^1;

//一年中每个月的天数，2月的天数由年份决定

uchar monthsdays[]={0,31,0,31,30,31,30,31,31,30,31,30,31};

uchar code DSY_CODE[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};

uchar Display_Buffer[]={0x00,0x00,0xbf,0x00,0x00,0xbf,0x00,0x00};

uchar Bit_Code[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};

uchar Current_Time[7];

char Adjust_Flag=0;

uchar K1num=0,K2num=0,K3num=0,flag=0,K3flag;

void delay(uint x)

{

uchar i;

while(x--)for(i=0;i<120;i++);

}

void Write_A_Byte_TO_DS1302(uchar x)

{

uchar i;

for(i=0;i<8;i++)

{

SDA=x&1;CLK=1;CLK=0;x>>=1;

}

}

uchar Get_A_Byte_From_DS1302()

{

uchar i,b,t;

for(i=0;i<8;i++)

{

b>>=1;t=SDA;b|=t<<7;CLK=1;CLK=0;

}

return b/1610+b%16;

}

uchar Read_Data(uchar addr)

{

uchar dat;

RST=0;CLK=0;RST=1;

Write_A_Byte_TO_DS1302(addr);

dat=Get_A_Byte_From_DS1302();

CLK=1;RST=0;

return dat;

}

void Write_DS1302(uchar addr,uchar dat)

{

CLK=0;RST=1;

Write_A_Byte_TO_DS1302(addr);

Write_A_Byte_TO_DS1302(dat);

CLK=0;RST=0;

}

void SET_DS1302()

{

uchar i;

Write_DS1302(0x8e,0x00);

for(i=1;i<7;i++)

{

Write_DS1302(0x80+2i,(Current_Time[i]/10<<4)|(Current_Time[i]%10));

Write_DS1302(0x8e,0x80);

}

}

void GetTime()

{

uchar i;

for(i=0;i<7;i++)

{

Current_Time[i]=Read_Data(0x81+2i);

}

}

void EX_INT0()interrupt 0

{

if(K1==0)

{

K1num++;

if(K1num==4)K1num=0;

}

if(K1num==3)

{

SET_DS1302();

Adjust_Flag=0;

K1num=0;

}

if((K1num!=0)||(K3num!=0))

{

if(K2==0)

{

Adjust_Flag=1;

if(flag==0)

{

if(K1num==1)

{

Current_Time[2]=(Current_Time[2]+1)%24;

}

if(K1num==2)

{

Current_Time[1]=(Current_Time[1]+1)%60;

}

}

if(K3num==2)Current_Time[6]=(Current_Time[6]+1)%99;

if(K3num==3)

{

Current_Time[4]++;

if(Current_Time[4]==13)

Current_Time[4]=1;

}

if(K3num==4)

{

monthsdays[2]=isLeapYear(2000+Current_Time[6])29:28;

Current_Time[3]++;

if(Current_Time[3]==monthsdays[Current_Time[4]]+1)

{

Current_Time[3]=1;

}

}

}

}

if(K3==0)

{

delay(5);

if(K3==0)

{

K3num++;

if(K3num==6)K3num=0;

}

}

if(K3num==1)

{

flag=1;

}

if(K3num==5)

{

flag=0;

K3num=0;

SET_DS1302();

Adjust_Flag=0;

}

}

void Timer0()interrupt 1

{

uchar temp;

TH0=(-50000)/256;

TL0=(-50000)%256;

temp++;

if(K3num==1)

{

if(temp==5)

{temp=0;flag=0;K3num=0;}

}

/ if(K1num==0&&(K3num==0||K3num==1))

{

if(temp==40)

{

// temp=0;

flag=1;

}

if(temp==80)

{

temp=0;

flag=0;

}

}/

}

uchar isLeapYear(uint y)

{

return(y%4==0&&y%100!=0)||(y%400==0);

}

void main()

{

uchar i,a,b;

TMOD=0X01;

TH0=(-50000)/256;

TL0=(-50000)%256;

EX0=1;

ET0=1;

TR0=1;

EA=1;

IT0=0X01;

while(1)

{

if(Adjust_Flag==0)GetTime();

a++;

if(a==20)

{ a=0;

b=!b;}

if(flag==1)

{

Display_Buffer[0]=DSY_CODE[Current_Time[6]/10];

Display_Buffer[1]=DSY_CODE[Current_Time[6]%10];

Display_Buffer[3]=DSY_CODE[Current_Time[4]/10];

Display_Buffer[4]=DSY_CODE[Current_Time[4]%10];

Display_Buffer[6]=DSY_CODE[Current_Time[3]/10];

Display_Buffer[7]=DSY_CODE[Current_Time[3]%10];

for (i=0; i<8;i++)

{

if(((i==0)||(i==1))&&((K3==0)||(K3num==2 )))

P2 = bBit_Code[i];//P2位码

else if(((i==3)||(i==4))&&((K3==0)||(K3num==3)))

P2 = bBit_Code[i];//P2位码

else if(((i==6)||(i==7))&&((K3==0)||(K3num==4 )))

P2 = bBit_Code[i];

else P2 = Bit_Code[i];

P0 = Display_Buffer[i];//P0段码

delay(2);

}

if(K1num==1)flag=0;

}

if(flag==0)

{

Display_Buffer[0]=DSY_CODE[Current_Time[2]/10];

Display_Buffer[1]=DSY_CODE[Current_Time[2]%10];

Display_Buffer[3]=DSY_CODE[Current_Time[1]/10];

Display_Buffer[4]=DSY_CODE[Current_Time[1]%10];

Display_Buffer[6]=DSY_CODE[Current_Time[0]/10];

Display_Buffer[7]=DSY_CODE[Current_Time[0]%10];

for (i=0; i<8;i++)

{

if(((i==0)||(i==1))&&((K1==0)||(K1num==1 )))

P2 = bBit_Code[i];//P2位码

else if(((i==3)||(i==4))&&((K1==0)||(K1num==2)))

P2 = bBit_Code[i];//P2位码

else if(((i==6)||(i==7))&&((K1==0)||(K1num==3 )))

P2 = bBit_Code[i];

else P2 = Bit_Code[i];

P0 = Display_Buffer[i];//P0段码

delay(2);

}

}

}

}

CLEO是玩家自制模组主程序，安装好CLEO后去找一些模组资源按照说明放入CLEO文件夹里面就可以再游戏中体验到模组的乐趣，建议LZ去SA吧看看，里面很多资源的，或者加一两个SA群，群共享里面很多类似的东西，而且不知道的还可以问群员

可以。

战锤40K:灵魂风暴

Windows 2000/XP

DirectX 90c (included on disc)

20 GHz Intel Pentium 4 or equivalent AMD Athlon XP processor

512 MB RAM (required for 8-player multiplayer games)

51 GB free hard drive space for installation

4x CD-ROM

64 MB DirectX 90c compatible AGP video card with Hardware Transform and Lighting

DirectX 90c compatible 16-bit sound card

以上就是关于请教一CPU有关的知识全部的内容，包括:请教一CPU有关的知识、什么是微内核设计系统的主要优点微内核设计系统中如何架构用户程序和系统服务的、求大神帮我看看我的单片机时钟程序，现在的问题是计数太快，尽量指出我的问题在哪里等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！