计算机组成原理核心总结

文章目录

1.冯诺依曼体系结构
2.运算器及控制器原理
- 2.1.指令执行
- 2.2.函数调用
- 2.3.程序装载
- 2.4.静态链接和动态链接
- 2.5.浮点数原理
3.CPU原理
- 3.1.CPU组成
- 3.2.流水线
- 3.3.CPU异常
- 3.4.GPU原理
- 3.5.CISC及RISC架构
3.存储器原理
- 3.1.存储器层次
- 3.2.局部性原理
- 3.3.高速缓存及多核CPU一致性
- 3.4.数据总线
- 3.5.输入输出设备
- 3.6.机械及固态硬盘
- 3.7.存储数据完整性

1.冯诺依曼体系结构

冯·诺依曼体系结构（Von Neumann architecture），也叫存储程序计算机结构。

“可编程”计算机
“可存储”计算机
可编程意味着程序可以是动态输入的，最早的计算机体系结构为不可编程式，所有的程序通过各类电路组合而成，完成特定的计算程序。
可存储意味着计算机的输入、输出、系统运行过程结果等都是可存储的。

冯诺依曼体系结构将计算机划分为几大组成部分：

1、运算器：算术逻辑单元（Arithmetic Logic Unit，ALU）和处理器寄存器（Processor Register）的处理器单元（Processing Unit），用来完成各种算术和逻辑运算。
2、控制器：包含指令寄存器（Instruction Register）和程序计数器（Program Counter）的控制器单元（Control Unit/CU），用来控制程序的流程，通常就是不同条件下的分支和跳转。在现在的计算机里，上面的算术逻辑单元和这里的控制器单元，共同组成了我们说的 CPU。
3、存储器：存储数据（Data）和指令（Instruction）的内存。以及更大容量的外部存储，在过去，可能是磁带、磁鼓这样的设备，现在通常就是硬盘。
4、输入输出设备：对应计算机的输入（键盘、鼠标、网络包）及输入（动作响应、显示器等等）

冯诺依曼体系计算机工作流程抽象：从输入设备读取输入信息，通过运算器和控制器来执行存储在存储器里的程序，最终把结果输出到输出设备中。

哈佛结构：哈弗结构与冯诺依曼体系的区别是将程序指令储存和数据储存分开的存储器，该结构被用在特定的微机/嵌入式控制器中较多，哈弗结构适用于程序固化的控制系统，指令不会被修改、数据存储也不会影响到指令运行，较为安全。

2.运算器及控制器原理

2.1.指令执行

1、指令集
CPU 就是一个执行各种计算机指令（Instruction Code）的逻辑机器。这里的计算机指令，就好比一门 CPU 能够听得懂的语言，我们也可以把它叫作机器语言。不同体系下的CPU支持不同的指令集。

2、从代码到指令集的过程
高级语言->汇编代码->机器码
汇编代码介于编程代码和机器码之间，是给开发人员阅读的底层助记码。其中不同CPU会把汇编代码翻译成不同的体系机器码。

编译型语言：将代码直接编译为汇编代码，再由机器翻译为机器码执行。
解释性语言：将代码编译为自有中间编码（如Java的class文件编码），再由虚拟机解析中间编码为机器码执行。

3、指令寄存器

PC寄存器：指令地址寄存器（Instruction Address Register），它就是用来存放下一条需要执行的计算机指令的内存地址。
指令寄存器：存放当前正在执行的指令。
条件结果寄存器：存放各条件和逻辑计算的执行结果。

一般程序的执行过程为：将编译好的指令按顺序存储在指令地址寄存器中，通过一个递增的指针来不断地取指令放入指令寄存器中，然后CPU不断地执行指令寄存器中的指令，并将中间结果放入条件结果寄存器中。

对于if…else这类分支执行指令，会在一般程序的执行过程上加上跳转指令（汇编中的jmp语句）。

2.2.函数调用

函数的调用过程是不断地向递归栈中压栈和出栈的过程，使得函数之间的调用保持调用顺序。
递归栈中需要保存每次函数调用的参数及结果，但是每个线程或者协程的递归栈大小通常是有限制的。Java中默认每个线程初始的程序栈为2M，go中默认初始的协程栈为2kb，当递归栈超出限制会触发StackOverFlow，也就是栈大小不足以继续递归调用。

2.3.程序装载

程序在通过编译、链接和装载后，变为内存中的可执行的指令，CPU才能够对指令进行读取执行。
通过链接器，把多个文件合并成一个最终可执行文件。在运行这些可执行文件的时候，其实是通过一个装载器，解析 ELF 或者 PE 格式的可执行文件。
装载器会把对应的指令和数据加载到内存里面来，让 CPU 去执行。

装载器会把指令中用到的内存地址成为“虚拟内存地址”，而实际处于硬件空间中的地址被称为“物理内存地址”，我们的程序只能够使用虚拟内存地址。
为了将虚拟内存地址及物理内存地址建立映射，通常的办法有：

分段
分页

1、内存分段
将一段连续的物理内存与虚拟内存地址建立映射，被称为分段。分段似的程序本身无需关系具体物理内存地址，对于不同物理地址的空间来说都映射到了连续的分段虚拟内存空间，解决了内存碎片问题。

2、内存分页
分段采用的是大空间的连续地址，分页采用的是小空间连续地址，进一步避免内存碎片问题。
和分段这样分配一整段连续的空间给到程序相比，分页是把整个物理内存空间切成一段段固定尺寸的大小。而对应的程序所需要占用的虚拟内存空间，也会同样切成一段段固定尺寸的大小。这样一个连续并且尺寸固定的内存空间，我们叫页（Page）。从虚拟内存到物理内存的映射，不再是拿整段连续的内存的物理地址，而是按照一个一个页来的。页的尺寸一般远远小于整个程序的大小。
在 Linux 下，我们通常只设置成 4KB。

分页的方式使得我们在加载程序的时候，不再需要一次性都把程序加载到物理内存中。我们完全可以在进行虚拟内存和物理内存的页之间的映射之后，并不真的把页加载到物理内存里，而是只在程序运行中，需要用到对应虚拟内存页里面的指令和数据时，再加载到物理内存里面去。

当要读取特定的页，却发现数据并没有加载到物理内存里的时候，就会触发一个来自于 CPU 的缺页错误（Page Fault）。
我们的操作系统会捕捉到这个错误，然后将对应的页，从存放在硬盘上的虚拟内存里读取出来，加载到物理内存里。这种方式，使得我们可以运行那些远大于我们实际物理内存的程序。同时，这样一来，任何程序都不需要一次性加载完所有指令和数据，只需要加载当前需要用到就行了。

2.4.静态链接和动态链接

程序的链接，是把对应的不同文件内的代码段，合并到一起，成为最后的可执行文件。这个链接的方式，让我们在写代码的时候做到了“复用”。同样的功能代码只要写一次，然后提供给很多不同的程序进行链接就行了，静态链接最大的问题就是相同的文件仍需要重复链接在一起，内存空间占据很大。

基于动态链接可以解决重复链接代码库内存占用大的问题。核心在于在动态链接的过程中，链接的不是存储在硬盘上的目标文件代码，而是加载到内存中的共享库（Shared Libraries）。

在 Windows 下，这些共享库文件就是.dll 文件，也就是 Dynamic-Link Libary（DLL，动态链接库）。在 Linux 下，这些共享库文件就是.so 文件，也就是 Shared Object（一般我们也称之为动态链接库）。

为什么同样一个程序，在 Linux 下可以执行而在 Windows 下不能执行了。其中一个非常重要的原因就是，两个操作系统下可执行文件的格式不一样。
Linux 下的 ELF 文件格式，而 Windows 的可执行文件格式是一种叫作 PE（Portable Executable Format）的文件格式。Linux 下的装载器只能解析 ELF 格式而不能解析 PE 格式。如果我们有一个可以能够解析 PE 格式的装载器，我们就有可能在 Linux 下运行 Windows 程序了。这样的程序真的存在吗？没错，Linux 下著名的开源项目 Wine，就是通过兼容 PE 格式的装载器，使得我们能直接在 Linux 下运行 Windows 程序的。而现在微软的 Windows 里面也提供了 WSL，也就是 Windows Subsystem for Linux，可以解析和加载 ELF 格式的文件。

2.5.浮点数原理

浮点数的科学计数法的表示，有一个 IEEE 的标准，它定义了两个基本的格式。一个是用 32 比特表示单精度的浮点数，也就是我们常常说的 float 或者 float32 类型。另外一个是用 64 比特表示双精度的浮点数，也就是我们平时说的 double 或者 float64 类型。

1、单精度32位浮点数组成

1bit符号位：s，表示浮点数正负
8bit指数位：e，表示浮点数的指数位
23bit有效数位：f，表示浮点数有效内容

2、浮点数加法精度损失
在极大浮点数加上极小浮点数时，会发生精度损失，比如200000000.0+1.0，结果仍为200000000.0。因为浮点数并不能精确表达，所以会出现“大数吃小数”的情况。
我们可以做一个简单的实验，用一个循环相加 2000 万个 1.0f，最终的结果会是 1600 万左右，而不是 2000 万。这是因为，加到 1600 万之后的加法因为精度丢失都没有了。这个代码比起上面的使用 2000 万来加 1.0 更具有现实意义。
所以在实际开发中，如果会存在极大浮点数累加的情况，要使用封装好的浮点数操作库。

3.CPU原理

3.1.CPU组成

1、指令周期
每条指令的执行过程为：在存储器中取出指令-在控制器中解码指令-在运算器中执行指令，这一个循环被称为“一个指令周期”或“CPU周期”。

2、CPU组成
CPU也就是中央控制器，是由控制器、运算器及存储器三者组成。

CPU的设计借鉴了哈弗结构，将指令存储和数据存储分离，可以更高效处理数据：

3.2.流水线

最开始的CPU为单指令处理，在一个指令处理完成之前，其他指令无法执行。
为了优化指令处理效率，CPU流水线诞生。如果我们有一个开发团队，我们不会让后端工程师开发完 API 之后，就歇着等待前台 App 的开发、测试乃至发布，而是会在客户端 App 开发的同时，着手下一个需求的后端 API 开发。那么，同样的思路我们可以一样应用在 CPU 执行指令的过程中。

3.3.CPU异常

异常可以分为：中断、陷阱、故障和终止。

中断：程序在执行到一半的时候，被打断了。这个打断执行的信号，来自于 CPU 外部的 I/O 设备。
陷阱：其实是我们程序员“故意“主动触发的异常，一般是发起系统调用或进入内核态之中。就好像你在程序里面打了一个断点，这个断点就是设下的一个"陷阱"。当程序的指令执行到这个位置的时候，就掉到了这个陷阱当中。
故障：和陷阱的区别在于，陷阱是我们开发程序的时候刻意触发的异常，而故障通常不是。比如，我们在程序执行的过程中，进行加法计算发生了溢出，其实就是故障类型的异常。这个异常不是我们在开发的时候计划内的，也一样需要有对应的异常处理程序去处理。
终止：当 CPU 遇到了故障，但是恢复不过来的时候，程序就不得不中止了。

3.4.GPU原理

GPU及图像中样处理器，相较于CPU来说，GPU更适合做大量简单计算，而CPU更适合做少量复杂计算。
GPU和CPU组成上的区别：
1、GPU只含有基本的取指令和执行指令操作，没有CPU中复杂的高速缓存和分支预测：

2、GPU运算天然并行化，支持大规模计算：

3、GPU拥有更多的线程上下文，支持多任务调度执行：

GPU 是一个可以进行“通用计算”的框架，我们可以通过编程，在 GPU 上实现不同的算法。另一方面，现在的深度学习计算，都是超大的向量和矩阵，海量的训练样本的计算。整个计算过程中，没有复杂的逻辑和分支，非常适合 GPU 这样并行、计算能力强的架构。

3.5.CISC及RISC架构

CISC和RISC是CPU结构的两种指令集，通常对应不同的CPU设计结构：

CISC：复杂指令集
RISC：精简指令集

3.存储器原理

3.1.存储器层次

存储器并不只有内存、硬盘，CPU中也存在自身的高速缓存等存储器，从CPU到硬盘，存储器的层次如下：

各个存储器只和相邻的一层存储器打交道，并且随着一层层向下，存储器的容量逐层增大，访问速度逐层变慢，而单位存储成本也逐层下降，也就构成了我们日常所说的存储器层次结构。

3.2.局部性原理

存储器中的局部性原理分为时间局部性及空间局部性。

时间局部性：假设一个数据被访问，那么短时间内还会被再次访问。
空间局部性：假设一个数据被访问，那么和它相邻的数据也可能被访问。

有了时间局部性和空间局部性，我们不用再把所有数据都放在内存里，也不用都放在 HDD 硬盘上，而是把访问次数多的数据，放在贵但是快一点的存储器里，把访问次数少的数据，放在慢但是大一点的存储器里。

时间局部性原理能够在存储器中保持有少量的缓存，而空间局部性原理会让相同的一批数据被“批量”读取出来，经典例子就是for循环中读取按行列读取数据速度会被按列行读取速度快一些，因为存储器实际上是按行维度把数据存储起来的，一次可以取出多行数据，但无法取出多列数据。

3.3.高速缓存及多核CPU一致性

CPU高速缓存位于CPU自身的存储器上，即L1、L2和L3缓存，也被称为CPU Cache。

1、高速缓存读取
CPU 进行数据读取的时候，无论数据是否已经存储在 Cache 中，CPU 始终会首先访问 Cache。只有当 CPU 在 Cache 中找不到数据的时候，才会去访问内存，并将读取到的数据写入 Cache 之中。当时间局部性原理起作用后，这个最近刚刚被访问的数据，会很快再次被访问。而 Cache 的访问速度远远快于内存，这样，CPU 花在等待内存访问上的时间就大大变短了。

2、高速缓存写入
我们使用的CPU通常都是多核的的。每一个 CPU 核里面，都有独立属于自己的 L1、L2 的 Cache，然后再有多个 CPU 核共用的 L3 的 Cache、主内存。

由于CPU在写入数据时，首先也会先写入到CPU Cache中，并且刷到主存（也就是实际内存）中，那么就会出现多核CPU下读写不一致问题，比如A线程通过CPU核心1写入数据，并刷到Cache1和主存中，但是线程B通过CPU核心2读取数据时，会先从自身的Cache2中读取，如果数据存在则返回，那么就会出现多CPU核心下，CPU本地高速缓存及主存不一致，这也是经典的Java volatile关键字问题。

通过CPU MESI（缓存一致性协议），可以让不同CPU核心直接读取主存数据，避免了不一致问题。

MESI协议的原理是只通过一个CPU核心负责写入数据，其他CPU核心对这份写入数据进行同步读取写入。如果写CPU核心的Cache失效，那么就会广播写失效到其他CPU核心，让其把自身Cache失效掉，那么在读取时就只能通过主存读取。

另外volatile关键字还引入了内存屏障来通知CPU不对某些指令进行重排序，避免了由重排序导致的数据不一致性。

3.4.数据总线

计算机里其实有很多不同的硬件设备，除了 CPU 和内存之外，我们还有大量的输入输出设备。可以说，你计算机上的每一个接口，键盘、鼠标、显示器、硬盘，乃至通过 USB 接口连接的各种外部设备，都对应了一个设备或者模块。如果各个设备间的通信，都是互相之间单独进行的。如果我们有 N 个不同的设备，他们之间需要各自单独连接，那么系统复杂度就会变成 N2。

数据总线避免各设备间相关关联，使用数据总线将CPU、内存及其他IO设备关联起来，各设备间通过该总线进行通信，每一个设备都向总线注册，其他需要读取该设备信息的设备则在总线中对该设备订阅。

3.5.输入输出设备

输入输出设备，并不只是一个设备。大部分的输入输出设备，都有两个组成部分。第一个是它的接口（Interface），第二个才是实际的 I/O 设备（Actual I/O Device）。我们的硬件设备并不是直接接入到总线上和 CPU 通信的，而是通过接口，用接口连接到总线上，再通过总线和 CPU 通信。
接口本身就是一块电路板。CPU 其实不是和实际的硬件设备打交道，而是和这个接口电路板打交道。我们平时说的，设备里面有三类寄存器，其实都在这个设备的接口电路上，而不在实际的设备上。接口中的控制电路会与PC系统总线相连接，并对实际的IO设备进行操作。

3.6.机械及固态硬盘

1、机械硬盘
一块机械硬盘是由盘面、磁头和悬臂三个部件组成。

盘面：盘面其实就是我们实际存储数据的盘片，盘面本身通常是用的铝、玻璃或者陶瓷这样的材质做成的光滑盘片。然后，盘面上有一层磁性的涂层。我们的数据就存储在这个磁性的涂层上。盘面中间有一个受电机控制的转轴。这个转轴会控制我们的盘面去旋转。
磁头：磁头从盘面上读取到数据，并转化为各类电信号传输给控制电路中。
悬臂：悬臂带动磁头，并将磁头定位到特定的磁道上去读取数据。

2、固态硬盘
机械硬盘在读取数据时需要不断地调整悬臂和磁头位置寻道读取数据，所以数据的读写效率是比较低的。
而固态硬盘通过数字化的方式来对数据进行读写，而不存在实际上的挪动悬臂等操作。
两者的比较：

3.7.存储数据完整性

磁盘在使用过程中肯定会出现部分损坏，一般使用RAID独立磁盘冗余阵列来达到磁盘数据完整性保证，之前的文章：https://arong.blog.csdn.net/article/details/119716707