# 0. 极简计算机结构介绍

对于以高级编程语言写代码的程序员而言，计算机硬件结构似乎完全是另一个领域的知识，从代码编写到代码执行，层层的中间环节所形成的抽象屏障，完全将底层的硬件模型隐藏了起来，似乎学习与掌握与之相关的知识变成了一项多余的事情。

然而不可见并不意味着不重要，高德纳在《计算机程序设计艺术》中说：“凡对计算机不是仅仅一时感兴趣的每个人大概或早或晚都将需要掌握至少一种机器语言”！当然对于凡人而言，即使不以“掌握”作为标准，但对于底层结构有所了解、对硬件模型有所印象也是大有裨益的。这不仅能夯实基础知识、完善理论体系，还能让我们看到如此庞大、复杂、精巧的计算机系统竟然建立在如此简单的概念之上，这本身就是一种极大的乐趣。合抱之木，生于毫末，诚如是也！

系统性讲解计算机架构的资料浩如烟海，本文是作者对自己学习笔记的一个整理，也是对相关知识进行精简、提炼的一次尝试。计算与存储是计算机系统的两个核心模块，本文尝试着从最基础的概念出发，用最少的篇幅介绍这两个模块的构造原理，以及由此而成的计算模型。文中内容主要来自于如下书籍：

* [编码：隐藏在计算机软硬件背后的语言](https://book.douban.com/subject/4822685/) \
  本书的经典程度无需赘言，应该在每个程序员的必读清单中！
* [The Elements of Computing Systems: Building a Modern Computer from First Principles](https://www.nand2tetris.org/) \
  本书简称 nand2tetris, nand 叫与非门，是最基础的逻辑门，Tetris 是俄罗斯方块，本书旨在讲解如何从 nand 开始搭建一个计算机系统，并最终在上面编写俄罗斯方块游戏。
* [Assembly Language Step By Step: Programming with Linux](https://3lib.net/book/3700817/6b970c) \
  前面章节中有关内存寻址的部分还是值得一读。

除此之外还有不少内容来自于网上的公开信息，本文保留了作者个人认为最重要、最基础的概念，如果有遗漏疏忽或者错误不当的地方，敬请斧正，不胜雀跃！

&#x20;谢谢您咧！


# 1. 布尔代数

布尔代数作为一个数学分支，研究的对象是两个真值变量：真、假（True/False），通常表示为 1 与 0. 真值的基本运算有三种：AND, OR, NOT, 他们被称为逻辑运算，其运算规则如下：

| x | y | x AND y | x OR y | NOT x |
| - | - | ------- | ------ | ----- |
| 0 | 0 | 0       | 0      | 1     |
| 0 | 1 | 0       | 1      | 1     |
| 1 | 0 | 0       | 1      | 0     |
| 1 | 1 | 1       | 1      | 0     |

我们可以通过这三种运算的组合形成更复杂的运算，例如：蕴含式（->），XOR:

| x | y | x -> y | x XOR y |
| - | - | ------ | ------- |
| 0 | 0 | 1      | 0       |
| 0 | 1 | 1      | 1       |
| 1 | 0 | 0      | 1       |
| 1 | 1 | 1      | 0       |

易得 x -> y 等价于 **(NOT x) OR y**, 而 x XOR y 等价于 **(x OR y) AND ((NOT x) OR (NOT y))**, 事实上任何逻辑运算都可以通过三种基本运算的组合实现。上文展示逻辑运算结果的表被称为逻辑表达式的真值表。

> &#x20;关于 x XOR y 的等价式，可以理解为 (x OR y) 表示 x 与 y 中至少一个为 1, 而 (NOT x) OR (NOT y) 限定两个不能同时为 1, 最终的效果就是 x 与 y 的值不同时，x XOR y 的值才为 1。

上述运算还满足一些基本的运算律，例如：

* 结合律：x AND (y AND z) = (x AND y) AND z, x OR (y OR z) = (x OR y) OR z
* 交换律：x AND y = y AND x, x OR y = y OR x
* 对偶律：NOT (x OR y) = (NOT x) AND (NOT y), NOT (x AND y) = (NOT x) OR (NOT y)

这里我们不对布尔代数做过多讨论，对于有编程背景的同学来说，上述内容应该非常熟悉。

香农在20世纪30年代对继电器开关电路的研究时发现，开关电路的行为与布尔代数的运算有着相似之处，例如开关的状态只有两种，开、关可以分别对应布尔代数中的 True 与 False，两个串联的开关电路对应于 AND 运算，而两个并联的开关电路对应于 OR 运算。当时，电路设计更多地依赖电气工程师的个人经验来完成，而缺乏系统性的研究、分析的手段，也就是说其更像是一门艺术，而非一门科学。香农敏锐地观察到使用布尔代数来分析开关电路的可能性，并在他的硕士论文《继电器与开关电路的符号分析》中对其进行了系统的阐述。该论文被认为是20世纪最重要的硕士论文之一，其为电路分析、设计找到了数学上的理论基础，从此以后，工程师们在设计电路时不必再考虑继电器、开关、晶体管等具体物件，而只需要考虑逻辑符号以及符号之间的逻辑运算，这为后来集成电路以及大规模集成电路的发展起到了至关重要的作用。

布尔代数由英国数学家乔治布尔于19世纪创建，目的是用代数的方式系统性地研究逻辑推演，布尔不曾想到，他所创建的学科如此深刻地刻画了一个世纪之后的信息世界。


# 2. 逻辑门（Logic Gates）

设想一个最常见的需求：我们需要为卧室灯装两个开关，一个在门口，一个在床头，使用任何一个开关开灯，都可以使用该开关或者另一个开关关掉，反之亦然。如何设计该电路呢？有经验的同学可能会想如何使用不同的开关通过并联、串联的方式组合起来以达成最终的控制效果，但稍稍分析一下这两个开关的行为，我们就会发现两个开关与灯满足如下状态关系：

| Switch-Door | Switch-Bed | Bulb |
| ----------- | ---------- | ---- |
| Off         | Off        | Off  |
| Off         | On         | On   |
| On          | Off        | On   |
| On          | On         | Off  |

如果我们用 0 表示 Off, 用 1 表示 On, 可以发现该状态与前文中的 XOR 的真值表完全一致。如果有一个基础的电路设备实现了 XOR 的功能，那么我们直接将两个输入端连上开关、输出端连上灯，就收工大吉了。

香农的工作让我们认识到电路设计可以转换为符号的逻辑运算，再回到布尔代数，我们知道任意复杂的复合逻辑运算都可以通过 AND, OR, NOT 三种基本运算通过组合的方式实现。对应到电路设计中，我们也需要能够完成对应逻辑运算的电路器件，这类器件被称为逻辑门（Logic Gates），三个基础的逻辑门分别叫与门（AND Gate）、或门（OR Gate）与非门（NOT Gate），符号如下：

![AND Gate, OR Gate, NOT Gate](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWEhQlUyVnku6Ijnq4%2Fand_or_not_gates.png?alt=media\&token=271daf9f-5788-4bfe-bf18-318066777b5b)

任意复杂的电路都可以通过这三个逻辑门组合而成。上文中的卧室电路需要一个异或门（XOR Gate），其电路符号以及可能的一种实现方式如下图所示：

![XOR Gate](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWEw_F5QSa5tzM1pzK%2Fxor_gate.png?alt=media\&token=a6df38d0-e2f4-4d4a-8e25-7527b3cdd0ac)

逻辑门是电路设计的基础组件，有了完成各种逻辑运算的逻辑门，电路设计就变成了一件搭积木式的工程了。

事实上如果继续简化逻辑门的基础单元，会发现可以将与非门（NAND Gate）当着最基础的逻辑门，与非门的真值表与符号表示如下：

![NAND Gate](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWF9S20rgroJkipAsq%2Fnand.png?alt=media\&token=e8ce387c-44c8-44da-9b94-aa68ca840814)

通过与非门构建 AND, OR, NOT 门的方式如下：

![Gates Based on NAND Gate](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWFMH72Rv7Woz4mMEV%2Fbased_on_nand.png?alt=media\&token=121a8748-36eb-4fc7-b741-3e34447d4cb5)

因此，我们可以将与非门看着是逻辑门最基础的积木。

> 制造逻辑门的物理元件随着技术的进步一直在进步，最开始人们使用继电器来完成电路开关的自动控制，后期使用电子管，世界上第一台通用计算机ENIAC便是使用电子管制造的。后来晶体管的发明颠覆了整个行业，晶体管在体积、能耗等各方面都优于电子管，这使得集成电路及大规模集成电路成为可能，当前一个指甲大小的芯片中包含的晶体管数以亿万。
>
> &#x20;可以参考 [Transistor Count](https://en.wikipedia.org/wiki/Transistor_count) 查看最新的芯片所包含的晶体管数量。


# 3.1 二进制加法

逻辑门可以用来作为电路的控制单元，例如上文中提到的卧室开关，那么我们能将其作为计算单元吗？

由于布尔代数只能表示两种状态，我们考虑用逻辑门来完成二进制的算术运算的可能性。而加法是算术运算的基础，所以我们先考虑二进制加法。二进制的加法与十进制一样，都可以从右至左逐位进行，如果相加的结果大于等于2，则向高位进位，参考下例：

```
 10011
 11001
---------
101100
```

我们先考虑最简单的场景，即两个一位数的加法，情况如下：

| A | B | Sum Bit | Carry Bit |
| - | - | ------- | --------- |
| 0 | 0 | 0       | 0         |
| 0 | 1 | 1       | 0         |
| 1 | 0 | 1       | 0         |
| 1 | 1 | 0       | 1         |

查看结果位（Sum Bit）与进位（Carry Bit）的情况，可以发现结果位相当于 **A XOR B**, 而进位相当于 **A AND B**. 这个结果非常重要，这意味着我们可以基于逻辑运算来构建算术运算。此处我们可以通过一个与门和异或门构建一个能够完成一位二进制加法的电路组件，其构建方式如下：

![Half Adder](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWGbfd4Y_G73u_IULF%2Fhalf_adder.png?alt=media\&token=95fc284a-0093-43c2-ba25-25d39c12ea44)

该电子组件叫着半加器（Half Adder），它只接收两个输入。而在多位的加法运算中，由于可能存在进位，因此每一位相当于在做三位的加法运算。如果我们将进位展现出来的话，上述加法等式表示如下：

```
 10011
 11001
100110 Carry Bit
----------------
101100
```

为了展示方便，我们将最低位的进位设置为0. 只通过半加器无法构建出多位的加法器，因为半加器只接收两个输入而无法接收和处理由低位产生的进位，能够接收进位的加法器叫着全加器（Full Adder），下图是全加器的一种电路设计：

![Full Adder](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWH5rLwtLYcmWZwEyT%2Ffull_adder.png?alt=media\&token=c8e07605-8da6-4cc8-85f7-083621a25b07)

有了全加器，就可以组装出任意位数的加法器了，例如下图是一个4位的加法器：

![4 Bit Adder](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWHGOaPrQbORpo25Ix%2F4bit_adder.png?alt=media\&token=b16d8292-fe26-4223-a928-bee68f6da31b)

该加法器能够完成4位的二进制加法运算：

```
   B3 B2 B1 B0
   A3 A2 A1 A0
--------------
C4 S3 S2 S1 S0
```

> &#x20;在现实系统中，由于存储空间始终是有限的，所以最高位通常会被丢弃，这种情况叫着溢出（Overflow）。溢出会导致系统的计算结果不正确，但这是系统需要处理的一种现实情况。


# 3.2 补码

在算术运算中，加法是最基本的操作，因为其他的运算都可以通过加法来完成。例如减法就是加上一个负数，而乘法与除法可以分别通过加法与减法来实现。

这里需要解决一个问题，就是如何在二进制中表示负数，以便将减法操作变为加法操作，而不是再重新设计一个减法器的电子组件。

&#x20;我们来看一下产生负数的最基本操作：0 - 1:

```
0000...0000
0000...0001
------------
1111...1111
```

不管是多少位的减法运算都可以表示为上述形式，因为需要借位，所以结果中每一位都是1(我们假设最左边依然借了一位过来，只是空间的有限无法展示）。那么如何用一串 1 表示 -1 呢？我们知道对于一个 n 位全是 1 的二进制数字, 其数值是： `2^(n-1) + 2^(n-2) + ... + 2^1 + 2^0`, 该数列的和为 `2^n - 1`, 因此，如果我们将最高位的权值设置为 -1 的话，那么整个二进制数字的值就刚好是 -1, 如下图所示：

![Two's Complement](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWI8nmtQXCr2wAPHYO%2Ftwos_complement.png?alt=media\&token=b72f3ec5-c0aa-40e0-9efc-e953f13eb57c)

我们来验证一下使用这种方式对整数进行编码时，能否用加法规则完成减法运算：

| 1 - 2 = -1                           | -1 - 1 = -2                             | 2 - 1 = 1                            | 1 - 1 = 0                            |
| ------------------------------------ | --------------------------------------- | ------------------------------------ | ------------------------------------ |
| <p>   000…0001</p><p>+111...1110</p> | <p>   111...1111</p><p> +111...1111</p> | <p>   000…0010</p><p>+111...1111</p> | <p>   000…0001</p><p>+111...1111</p> |
| 111…1111                             | 1111…1110                               | 1000…0001                            | 1000…0000                            |

表格后三列的结果中最高位产生了进位，在现实系统中会因为溢出而被丢弃，因此忽略后三列的最高位后，各列的实际结果为：

1. 111…1111 = -1
2. 111…1110 = -2
3. 000…0001 = 1
4. 000…0000 = 0

所有的运算与预期结果完全一致！

这种对数字进行编码的方式叫补码（2’s complement），补码的优点在于我们可以使用同一套计算规则完成加法、减法两种运算，这样所有的算术运算，包括乘法、除法以及开平方根等，都可以使用加法来完成了。这意味着理论上仅仅通过全加器，使用补码对数字进行编码，就可以搭建出具备完整计算能力的计算机。

补码让加法器成为了二进制世界中算术运算的基础积木。


# 3.3 ALU

前面章节我们简单讨论了计算机系统最基础的一些模型：

* 布尔代数：数字电路的数学基础
* 逻辑门：数字电路的物理媒介基础
* 与非门：逻辑门的基础
* 加法器与补码：二进制计算能力的基础

基于这些知识，我们已经可以设计出一个具备算术、逻辑运算能力的电路组件了，该组件被称为 ALU(Arithmetic Logic Unit),  ALU 是 CPU 的核心部件，负责所有的计算工作。我们以位数来限定 ALU 的计算能力，下图是一个 16 位 ALU 的示意图：

![16 Bit ALU](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWJOMG8AM4GSW0cTcJ%2F16bit_alu.png?alt=media\&token=40294e30-9f36-47a5-a7fb-2439a3855d06)

其中 x, y, out 是 16 位的整数，采用二进制补码进行编码，x 与 y 是输入，out 是输出。图下方的 zr, ng 是标记位（Flag），zr 表示结果为 0, ng 表示结果为负。

图上方的 zx, nx 等 6 位叫控制位（Controll Bits），用来告诉 ALU 执行何种操作，例如是执行 x + y 还是 x & y 。 注意，我们讨论过所有的逻辑运算都可以通过 NAND 来完成，而所有的算术运算都可以通过加法来完成，所以理论上 ALU 只需要提供这两种运算，这样的话控制位只需要一位就足够了，更复杂的运算可以让 ALU 反复执行基础运算来达成。但实际上 ALU 是一个粒度更大的复合组件，因此会封装更多的复合操作，例如可以让 ALU 直接完成 x & y 运算, 这样可以极大简化 CPU 指令集的设计。复合功能的总数受控制位数目的限制，图中 ALU 的控制位有 6 位，因此最多可以支持 2^6=64 种运算。如何设计这 64 种运算是 ALU 设计时需要考虑的重要课题，因为 ALU 功能的设计会直接影响到 CPU 指令集的设计。


# 4.1. SR Latch：如何存储 1 Bit

到此为止，我们知道了如何使用逻辑门构建计算单元，但不管是基础的逻辑门、加法器，还是复杂的 ALU, 其任意时刻的输出都仅仅与当前的输入相关，而与之前的输入或输出无关，这种电路叫着组合逻辑电路（Combinational Logic Circuit）。

组合逻辑电路的名字反应了其内在本质：即任意时刻的输出仅仅是当前输入的组合结果。组合逻辑电路是一个无状态的功能模块，这种电路具备计算能力但没有存储能力，因为只要输入改变，作为计算结果的输出就会发生改变，电路无法将结果“锁”在电路内部以供“将来”使用。

想要打破这种限制，我们可以尝试着将电路的输出作为反馈，再次作为输入信号接入到电路中，以期望让电路形成一种稳定状态。最简单的稳定态电路可以使用两个非门（Not Gate）组成：

![Two NOT Gates](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWKJcOKAFsO14CxdvT%2Ftwo_not_gates.png?alt=media\&token=9bd3a18c-7a11-4b47-941b-8ffee1d6c3dd)

通过将该电路输出引脚 Q 又接入到输入引脚，这样该电路将一直保持稳定状态，根据信号的初始设置不同，Q 将一直处于状态 1 或者处于状态 0。但由于该电路没有输入引脚，因此并没有什么实用价值，下面我们使用两个或非门（NOR Gate）构建一个具有输入引脚的等价电路：

![Two NOR Gates](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWKYX9RVF3TbUnleUP%2Fsr_ff.png?alt=media\&token=48766443-4dcd-4cd6-b2e2-086dd6c018d8)

> &#x20;或非门（NOR Gate）的真值表为：

| A | B | A NOR B |
| - | - | ------- |
| 0 | 0 | 1       |
| 0 | 1 | 0       |
| 1 | 0 | 0       |
| 1 | 1 | 0       |

当 S = 0, R = 0 时，该电路与上面由两个非门组成的电路完全等价。我们将该电路稍稍“旋转”一下，得到如下电路：

![SR Latch](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWKq24N9GT4XsRdVQ2%2Fsr_latch.png?alt=media\&token=46b83754-a3e5-4869-99b8-0a669f5fb783)

该电路暴露了两个输入引脚：S 与 R, 此处我们要求输出引脚 Q 与 ^Q 的信号互反。电路的真值表如下：

| #No | S | R | Q | ^Q |
| --- | - | - | - | -- |
| #1  | 0 | 0 | 1 | 0  |
| #2  | 0 | 0 | 0 | 1  |
| #3  | 1 | 0 | 1 | 0  |
| #4  | 0 | 1 | 0 | 1  |
| #5  | 1 | 1 | 0 | 0  |

该电路的稳定状态只有以上 5 种，我们依次来分析分析当设置 S 与 R 时，输出信号 Q 与 ^Q 的情况：

1. &#x20;Set S = 1, R = 1: Invalid \
   虽然此时电路可以处于稳定状态，但我们认为其是非法的。因为一来 Q 与 ^Q 都是 0, 违反了我们的约定；二来在将 S, R 同时设置为 0 时会存在一个竞态条件：此时 Q 及 ^Q 理论上都会变为 1, 如果 Q 的值率先传递给 S, 则 ^Q 会变为 0; 而如果是 ^Q 的值率先传递给 R, 则 Q 会变为 0. 即我们无法知道电路的状态变化是 #5 -> #1 还是 #5 -> #2.

   &#x20;竞态条件存在的根本原因是因为电子信号的传递是需要时间的，关于电路设计中时间的概念会在后续讨论时钟时详细讨论。
2. Set S = 0, R = 0 \
   此时不管是 Q = 0, ^Q =1, 还是 Q = 1, ^Q = 0 都可以是电路处于稳定状态，而电路最终会处于何种状态取决于 Q 与 ^Q 的上一个状态。实际上，稍加分析一下就会发现，不管是 #4 -> #2 还是 #3 -> #1, Q 与 ^Q 都会保持各自之前的状态不变。
3. Set S = 1, R = 0 \
   S 为 1 必然导致 ^Q 为 0, 而 R 也为 0, 所以 Q 为 1. 注意此时 Q 与 ^Q 的状态与其之前的状态无关，当 S = 1 时，Q 的值必然被设置为 1.
4. Set S = 0, R = 1 \
   与 S = 1, R = 0 时的状态相反，此时 S = 0 必然导致 Q 被设置为 0.

如果我们将 0 作为任何电路的初始状态的话，可以发现当 S = 1, R = 0 时，Q 总会被设置为 1, 而 S = 0, R = 1 时，Q 总会被重置为 0, 而当 S = 0, R = 0 时，Q 将保持之前的状态不变，将其“锁（Latch）”在电路内部，也就是说，此时该电路具备了存储能力，并且我们可以通过 S, R 的信号对内部值进行修改！

此处 S 表示 Set, R 表示 Reset， 所以该电路叫着 SR Latch。

能够维持两种稳定状态的电路被称为双稳态锁存器（Bistable Latch），由于该电路可以稳定地表示两种状态，因此它具备存储 1 Bit 信息的能力。只要能够存储 1 Bit, 就可以存储任意 Bit, 因为我们制造出了搭建存储芯片的基础积木！

这种将输出又反馈进输入的电路叫着时序电路（Sequential Circuits），时序电路是构造存储电子芯片的基础。时序电路与组合电路的区别在于反馈模式，反馈是将过去的状态与当前的输入组合在一起，用以确定当前的输出，这里本质上是在电路设计中引入了时间的概念，即电路当前的输出不仅与当前的输入有关，还与“之前”的电路状态有关。


# 4.2. 时钟：计算机中的时间模型

到目前为止，不管我们是讨论组合电路还是时序电路，都没有考虑时间的因素，我们认为输入信号改变之后，输出信号的变化是完全实时的。而在现实中，所有的事情都会有延迟，一来电路组件的多个输入信号不可能达到“理论上”的同时输入，总会存在一个时间差，而且一个电路组件的输入信号通常是其它组件的输出信号，这会导致输入信号到达的时间差更加不可控；二来电路组件在进行“计算”时总是需要花费时间，“计算”的本质就是电子信号从电路的输入引脚传达到输出引脚的过程，所以电路越复杂，所需要的时间也就越多。所以对于任意的电路组件，当提供了输入信号之后总是要“等一会儿”，然后输出引脚上的信号才会变成正确的结果，这个等待的过程叫着同步。

如何确定同步时长，是芯片设计的重要考虑因素！

芯片就是一块集成了数以亿万个基础逻辑门的复杂电路，这些基础逻辑门像搭积木一样构成了最终的产品，此处我们将其看着一个黑盒，当提供不同组合的输入时，电子信号通过不同的路径最终形成输出结果，这里的输出结果可能是输出引脚上的信号，也可能是对内部状态的某种修改，不同路径代表着不同的计算，我们将这个过程看着是芯片执行了一条指令。不同指令的用时是不一样的，为了保证每条指令都正常执行，我们需要使用**耗时最长的指令所需要的时间**作为整个芯片的同步时长。

假设芯片的同步时长为 t, 也就是说系统在运行过程中，需要一种触发机制，在 0, t, 2t, 3t, … 等时刻触发芯片执行下一条指令。这种时刻的划分方式被称为时钟，而同步时长 t 被称为时钟周期。可见时钟周期的频率就是系统执行指令的频率，因此在设计时钟周期时，一方面要让其足够长，能够无差错地同步系统；另一方面也需要其尽量短，以便提升系统的运行速度。当前的主流 PC 处理器的时钟频率已经达到了数 GHz 级别，也就是说每秒钟 CPU 能够执行几十亿条指令。

&#x20;模拟时钟信号的电子元件叫着振荡器（Oscillator），振荡器周期性地在 0, 1 这两种状态之间变换，完整的一次变换就等价于一个时钟周期。下图的脉冲信号是时钟周期的一个可视化效果：

![Clock](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWMhK-kFm4omPBsQ_Z%2Fclock.png?alt=media\&token=22e77a99-73a8-4f93-822a-ccbb791ac147)

可见现实世界中连续的时间，在计算机系统中被划分成了一个个等长的单位，变成了一个离散的概念。在这种时间模型下，整个系统的状态都是与时钟周期挂钩的，对系统状态的任何改变都要在下一个时钟周期才完全生效，而在同一个时钟周期内，系统的状态变化被看着是一个不可分割的原子行为。

在计算机系统中，统一的时钟信号会接入到所有的芯片中，以确保整个系统在相同的节奏下工作。

> 我们此处默认了一个情况，即我们的设计采用的是[同步电路](https://en.wikipedia.org/wiki/Synchronous_circuit)而不是基于事件的[异步电路](https://en.wikipedia.org/wiki/Asynchronous_circuit)。
>
> 在将多个电路组件组合起来时，同步电路需要等待自己上游电路的输出结果，因此需要通过时钟来进行同步；而异步电路是基于事件通知的，不需要时钟。同步电路设计起来更简单，异步电路更加复杂，因此现在的芯片设计都是基于同步电路进行的。


# 4.3. D Flip-Flop：以时钟为脉搏的存储器

前文中提到的 SR Latch 具备了存储 1 Bit 数据的能力，而时钟用来同步电路的运行，那么如何利用时钟信号来控制数据进行写入呢？下图所示的 D Latch 可以实现该效果：

![D Latch](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWNdefQPYqRAWYlLXa%2Fd_latch.png?alt=media\&token=20ce8a2e-0fc6-48ad-b10c-9949cc3f49b9)

分析该电路可以发现，时钟信号控制着数据的写入情况：

* 当时钟信号 C = 0 时，Q 不改变
* 当时钟信号 C = 1 时，Q 的值被设置成 D

细心的读者会发现：D Latch 还解决了 S 与 R 不能同时为 1 的问题。

D Latch 的特点是，当时钟信号是 1 时， Q 的数据总是会保持与 D 一致。这种机制的电路叫着 Level-trigger, Level 指时钟脉冲信号的上沿（Top level）或下沿（Bottom level）。上图的 D Latch 是上沿触发的，信号 D 和 Q 随着时钟脉冲信号 CK 变化的示意图如下：

![](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWNx6dxrZsDZsbQo9q%2Flevel_trigger_dlatch.png?alt=media\&token=6f80c313-b6ec-4696-a5ea-1b13faded528)

注意在最后一个时钟的上沿阶段，Q 随着 D 变化了两次，而这正是 D Latch 的特点：在时钟信号为 1 时，输出信号 Q 总是能够实时**捕捉**到输入数据 D 的变化。

与 Level-trigger 相对应的是在时钟信号变化的瞬间进行触发，而在其它时候保持 Q 的信号不变。这种触发方式叫着 Edge-trigger, 下图展现的是通过两个 D Latch 与一个非门组装的效果图，上面的电路通过上升沿触发，下面的通过下降沿触发：

![D Flip-Flop](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWOAbAwjpGh0p70n98%2Fd_flipflop.png?alt=media\&token=9312ba56-c82a-4b2d-aea9-2a03bc67c3ff)

我们来分析 A, 一个通过上升沿触发的电路组件：当 CLK 为 0 时， CLK0 为 1, 因此 Q0 的值会一直与 D 保持一致，而由于 CLK1 此时为 0, 所以输出端 Q 的值不会改变；但当 CLK 变为 1 时，CLK1 的值变为 1, 此时 Q0 的值会立马写入 Q, 而由于 CLK0 此时为 0, Q0 的值将保持不变，所以 Q 的值将会锁定为 CLK 由 0 变为 1 时的瞬时值，即数据的写入是由时钟信号的上升沿触发的。

这种电子组件叫着 D Flip-Flop, D 可以代表 Data, 也可以是 Delay, 简称为 DFF. 由于 DFF 总是在时钟信号变化时才触发数据的写入操作，因此其输出信号与输入信号满足如下关系：out(t) = in(t - 1), 其中 t 为任意时钟周期。一个 DFF 的信号在时钟周期上的表示如下图所示：

![DFF Behavior](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWOUTW1f1DKge4zFgx%2Fdff_behavior.png?alt=media\&token=84254b7d-1ac0-4974-944d-e06da65980bb)

DFF 是构建存储型电子芯片的基础元件，寄存器（Register）、内存（RAM）等都可以基于 DFF 进行构建，所有的 DFF 都连接到系统的时钟信号上，这样可以保证所有对数据的写入操作都会在下个时钟周期生效，而这正是我们期待的效果。


# 4.4. 地址：可寻址的存储单元

有了能够存储 1 Bit 数据的 DFF 后， 我们可以将多个 DFF 并起来构建出能够存储多位数据的电子元件。下图演示的是一个存储 4 Bit 数据的电子元件的构建方式：

![4 Bit Register](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWOvjAQ52sv0Fm252y%2F4bit_register.png?alt=media\&token=e7f68ec5-8f9c-4256-841c-841bdecdf86c)

我们增加了一个开关引脚叫 Write, 当要写入数据时才将该线路设置为 1, Write 信号与时钟信号一起通过一个 AND 门来共同控制数据的写入，不考虑电路内部实现，该电路图可以简化为：

![4 Bit Register](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWPBNo6Z9Au9Jjl7Mn%2F4bit_register_blackbox.png?alt=media\&token=fbe234bb-ce93-4cad-92f5-fc522ff2d5e8)

我们将该组件的输入信号分为两类：数据信号（DI0 到 DI3）与控制信号（Write 与 CLK）。

该电子元件是构成寄存器或内存芯片的基础组件。而 CPU 中包含多个寄存器，内存的存储容量则更大，因此当 CPU 存取数据时，必须指定寄存器或者内存的具体位置，也就是说 CPU 除了提供数据信号与控制信号之外，还需要提供地址信号。而上图的电子元件的输入中并不包含地址信号。

因此我们最好重新设计存储多位数据的电子元件，让其也能接受地址信号作为输入。

现在我们有了能够存储 4 Bit 的电子组件，假设想要存储 16 Bit 的话需要 4 个该组件，我们可以将 4 个组件中的 16 个 DFF 看成一个 4 X 4 的矩阵，如果将每 4 Bit 看着一个数据单元的话，那么存储一个数据单元的方式有两种，如下图所示：

![4x4 Bit Matrix](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWPThpzDygjrmYYf1y%2F4bit_matrix.png?alt=media\&token=0e07a057-1fc1-43f8-8fea-5ac694ddd0ce)

如果使用蓝色方框的存储方式，那么我们需要单独设计寻址电路来定位每个4位寄存器，因为将地址信号作为每个组件的输入是无意义的，每个4位寄存器就是一个独立的存储单元。

红色方框这种存储方式也满足需求，但对于每个数据单元，每个组件仅贡献了 1 Bit 的存储能力，因此我们需要某种机制，能够使我们从寄存器的 4 Bit 中筛选出任意一位进行操作。下图中我们将所存放的 4 个数据单元按照二进制依次编号：

![](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWQ1pnaOLUI7kX1H8T%2F4bit_col.png?alt=media\&token=0c5e991f-ee7e-45f8-b549-63ce06e1fe01)

事实上，这两位数字编号代表的便是一个组件内部各个 DFF 的地址，在每次进行读写操作时，我们都需要将该地址作为输入传入寄存器，以便筛选出对应的 DFF。对于二进制而言，n 位地址能够寻址的范围是 \[0, 2^n), 因此上图中每个组件需要 2 个输入引脚作为地址信号。不考虑内部实现，加入地址引脚的组件如下图所示：

![](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWQIOFAqW_dfGMFF9j%2F4bit_addr_pin.png?alt=media\&token=e51847d0-6a17-4295-afea-d5439b5c6f29)

注意：此时输入、输出引脚都变成了一位，因为现在每次只会操作组件内部的一位数据，具体是哪一位数据通过 Addr 引脚来指定。同时我们将 Write 引脚改为了 R/W, 该位为 1 时用以写入数据，为 0 时用以读取数据。

现在我们来讨论如何利用地址信号来选择组件内部的目标位置。

在写入端，如果我们能够将 Write 信号仅仅“路由”到目标 DFF 中，而将其它三个 DFF 的 Write 位保持为 0 的话, 就能顺利完成写入操作。以本文中的 2 位地址为例，该“路由电路”的示意图如下：

![2-4 Decoder](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWQbBDFPijLCdsIHRH%2F2_4_decoder.png?alt=media\&token=e584f179-b49b-4f10-b080-0abf03c4ae65)

当输入信号 DI 为 1 时，该电路的真值表为：

| Addr0 | Addr1 | DO0 | DO1 | DO2 | DO3 |
| ----- | ----- | --- | --- | --- | --- |
| 0     | 0     | 1   | 0   | 0   | 0   |
| 0     | 1     | 0   | 1   | 0   | 0   |
| 1     | 0     | 0   | 0   | 1   | 0   |
| 1     | 1     | 0   | 0   | 0   | 1   |

该电路叫着 Decoder, 上图是一个 2-4 Decoder, Decoder 电路可以使用与门与非门构建，例如下图是一个 2-4 Decoder 的电路图：

![2-4 Decoder Impl](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWQjnu3ztqqOwPD4xZ%2F2_4_decoder_impl.png?alt=media\&token=4278d033-d688-4b3c-9e1a-c4d259f79f34)

在读取端，我们需要根据地址信号选择目标 DFF 的输出信号，该电路是 Decoder 的一个逆向操作，以本文的 2 位地址为例，该电路示意图如下：

![4-1 Selector](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWQsxN1Yi533JPq1pp%2F4_1_selector.png?alt=media\&token=e1ad3b1e-c1d1-4c62-87bc-2cdc307eedba)

该电路的输出信号与输入信号的关系为：

| Addr0 | Addr1 | DO  |
| ----- | ----- | --- |
| 0     | 0     | DI0 |
| 0     | 1     | DI1 |
| 1     | 0     | DI2 |
| 1     | 1     | DI3 |

该电路叫着 Selector, 上图是一个 4-1 Selector, 可以通过如下方式实现（三个输入引脚的与门可以通过串联两个与门实现）：

![4-1 Selector Impl](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWR-J1uUC8v3TeN1uF%2F4_1_selector_impl.png?alt=media\&token=7869d555-eaa5-4f4b-97ee-036fddaff3ae)

有了 Decoder 与 Selector, 我们就可以设计出一个带地址引脚、拥有 4 Bit 空间的基础存储组件了，如下图所示：

![Addressable 4 Bit Register](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWR6H6i-ZQbr1WZSFY%2Faddressable_4bit_ramunit.png?alt=media\&token=3357d941-bdaa-4d01-96d9-6181821803b6)

该组件是构建大容量存储芯片的基础积木，寄存器、内存都可以基于该组件组装出来。


# 4.5. 内存：大容量的存储芯片

上一节的最后我们设计了一个可寻址的存储组件，我们将其称为一个 4x1 内存单元，其中 4 表示该组件的数据容量为 4 Bit, 而 1 表示其数据带宽只有 1 Bit, 也就是说该组件每次只能处理 1 Bit 的数据。我们知道计算机内部的基础数据单位是字节（Byte），一字节包含 8 Bit, 这已经超出了该组件的存储容量；而即使是 Intel 在上世纪70年代发布的第一代 x86 系列芯片 8086, 其寄存器也是16位的，这意味着该芯片的数据带宽为16位，而现在主流的系统都已经上升到了64位。由此可见，单个该组件的实用价值极其有限。

但该组件并不是我们设计的最终产品，而是基础的内存单元，我们在设计该组件时，已经将一个完整的存储芯片所涉及的概念都整合进去了，包括输入、输出、地址、控制信号，因此当我们需要更大容量、更大数据带宽的存储组件时，所面临的问题实质上只是如何组装扩容了。本节我们将讨论如何通过串联扩容数据容量，通过并联扩容数据带宽。

接下来我们来看一下如何通过串联两个组件，构造出一个容量为一字节、即一个 8x1 的内存单元。不考虑内部实现，一个 8x1 内存单元的接口如下图所示：

![8x1 RAM Array](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWRspKAwCic5gOiZyN%2F8x1_ramarray.png?alt=media\&token=dcf7aee3-63b8-4b56-a987-9c3a564a5979)

容量的增加导致 8x1 内存单元需要 3 根地址总线，这是它在接口上与 4x1 内存单元唯一的变化，如何处理多出来的最高位地址信号 A2 是解决问题的关键。

> &#x20;将 A2 看着是最高位地址信号是指三位地址信号按照 A2A1A0 进行排列。

不难发现，我们可以将 A2 作为如何选择内部两个 4x1 内存单元的指示信号，即当 A2 = 0 时，我们选择图中的RU0进行数据读取操作，而 A2 = 1 时选择RU1。也就是说我们将一字节中的低四位存放在 RU0 中，高四位存放在 RU1 中。通过在输入侧增加一个 1-2 Decoder 来控制写入信号、在输出侧增加一个 2-1 Selector 来选择输出信号, 就可以达成这种效果，最终的电路图如下所示：

![8x1 RAM Array Impl](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWS742qlB4sT03vBLq%2F8x1_ramarray_impl.png?alt=media\&token=44ec2f71-1f01-44c1-a960-525084ead5a7)

这样我们就得到了一个 8x1 的内存单元。通过相同的方式，我们可以将两个 8x1 的内存单元扩容成一个 16x1 的内存单元，以此类推我们可以组装出任何容量为 2^n Bit 的内存单元。

现在我们来看如何通过并联的方式增大数据带宽。

我们先考虑通过 8x1 内存单元构建 8x2 的数据单元，即将数据带宽增大到 2 Bit. 不考虑内部实现，一个 8x2 内存单元的接口如下图所示：

![8x2 RAM Array](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWSP0CFJHi7bi3zyr1%2F8x2_ramarray.png?alt=media\&token=9711e920-c918-4bf9-8938-3b208f80e1ef)

扩容数据带宽的思路很直观，我们在内部并联两个 8x1 内存单元 RU0 与 RU1，这两个内存单元共享地址信号（A2A1A0）与控制信号（R/W, CLK），然后将 DI0 与 DO0 连接到 RU0 的对应引脚，将 DI1 与 DO1 连接到 RU1 的对应引脚即可。示意图如下（图中仅标记出了数据引脚的连接方式，而省略了地址信号及控制信号的连接方式）：

![8x2 RAM Array Impl](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWSXd-3ON_PSJPihR-%2F8x2_ramarray_impl.png?alt=media\&token=7461cfec-3002-4f08-8225-de86165229ca)

这样我们就构建好了一个 8x2 的内存单元，不难发现，使用同样的方法可以构建出任意 8 x N 的内存单元。

本节我们所讨论的内容仅仅是理解内存芯片的一个模型，实际上的芯片结构要复杂得多。例如在计算机内部，内存的最小寻址单位是字节，因此我们可以将内存构造成一个 N x 8 的内存阵列，但 CPU 与内存的数据带宽（即数据总线）要明显高于 8 Bit, 例如当前主流芯片的数据总线是 64 位，因此对于内存而言，其每次需要操作的数据是从地址信号开始的连续 8 字节，在内存芯片内部需要做好这种转换。


# 4.6. 寄存器：CPU 的存储单元

CPU 与内存是两个独立的芯片，计算机运行时，CPU 通过总线与内存交换数据，这种数据传输通道的速率远远低于CPU的时钟周期，为了加快CPU的处理速度，芯片制造者们在CPU内部加入了寄存器（Register）。

寄存器是位于 CPU 内部的存储组件，构造寄存器的底层原理与构造内存是一样的。CPU 中的寄存器分为专用寄存器与通用寄存器，专用寄存器有专门的用途，甚至其内容不允许用户直接修改，例如 PC(Program Counter); 而通用寄存器的用途由编程人员自己决定。下图是英特尔 X86 系列最早的芯片 Intel 8086 所定义的寄存器：

![Intel 8086 Registers](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWSw8QrutKihpO203y%2F8086_registers.png?alt=media\&token=d96a1dd3-af95-4233-8138-b1e9385658f2)

寄存器的数目是极其有限的，因此 CPU 内部的每个寄存器都有固定的编码，例如上图中，寄存器 AX 指代的就是由 AH 与 AL 两个 8 位寄存器组成的一个 16 位寄存器。也就是说，从编程人员的视角来看（除非直接写二进制的机器指令），CPU 指令对寄存器的寻址是通过名字进行的，这是与内存寻址方式最大的不同。


# 5. 计算模型与机器语言

在前面章节中我们深入底层，详细讨论了计算机的计算单元与存储单元的构造方式，这一节我们将视野提升一个抽象层次，来看一下通过这些组件构建起来的最基础的计算机模型，并简单讨论一下为该模型设计指令集所需要考虑的因素。

到目前为止，我们讨论的内容局限于两个芯片：

* CPU: 计算芯片，前文提到的ALU、寄存器都是CPU的组成部分，除此之外CPU还至少需要一个控制组件（Control Unit），用来“指挥”CPU的工作
* 内存: 存储芯片，CPU 所执行的指令以及操作的数据都存储在内存中

CPU 与内存通过总线（Bus）进行通信，总线上包含三种信号：地址信号、数据信号、控制信号。如下图所示：

![](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWT_NInQ1npcJjz_Yu%2Fcpu_arch.png?alt=media\&token=f75d04dc-1d34-41df-ab5a-fadef6651f0f)

虽然该图很简单，但已经呈现出了一个最基本的计算模型：在 CU(Control Unit) 的控制下，CPU 反复地执行存放在内存中的指令，指令的执行效果就是将内存或寄存器中的数据扔进 ALU 做运算，再将结果写回内存或寄存器。至于CPU来回倒腾这些数据到底是为了什么，这是宏观的层面上所具备的意义，可能是在完成一个交易、可能是在模拟一个电子游戏、也可能是在播放一部电影。但不管是什么事情，在微观层面的体现都是这样。

> 如果读者熟悉图灵机模型，会发现上文所说的计算模型就是图灵机的一种映射。事实上如果我们再加上输入与输出设备，就是一个冯诺伊曼架构的计算机模型。

CPU 执行指令通常划分成多个阶段：取指、解码、执行、存储，一个完整的循环被称为 CPU 的一个执行周期。整个流程由 CU 主导，CPU 的各个组件会在一起密切配合，例如寄存器 PC(Program Counter) 总是保存着下一条指令的内存地址，PC 的内容由当前执行的指令决定；如果需要 ALU 参与运算，CU 在解码后需要将各种输入信号传给 ALU。这些逻辑需要非常复杂的硬件电路来支撑，但这里我们不再深入讨论硬件实现，而是将其看着是一个功能完善的整体。

在该模型下，我们需要如下几类指令：

1. 算术、逻辑运算。该工作通过 ALU 来完成，输入、输出来自寄存器或者内存
2. 数据传输。将数据在寄存器与内存之间传输
3. 流程控制。如何获取并执行下一条指令，程序默认是顺序执行的，我们还要考虑如何完成条件判断以及完成程序跳转等

设计指令集时需要考虑如下因素：

1. 内存模型 \
   既然 CPU 的毕生精力都在倒腾内存中的数据，那么如何对内存进行寻址是指令集的重点。内存模型决定了寻址方式，以及能够寻址的内存空间大小。例如上文中提到的 Intel 8086 芯片，其为了在16位寄存器中支持20位的地址空间，采用的是分段寻址（Segmented Addressing）模式。
2. 指令格式
3. 寄存器种类 \
   哪些寄存器是专用寄存器，哪些是通用寄存器。例如 Intel 8086 芯片中，为了支持分段寻址，专门设计了段寄存器（Segment Registers）与索引寄存器（Index Registers）。

其中最重要的是内存模型，内存模型会显著影响上层程序的设计，例如操作系统的实现。事实上内存地址的用途是多样化的，不仅仅局限在对内存芯片的寻址上，如果我们重新审视 CPU 与内存的关系，会发现 CPU 根本不知道存储芯片的存在，CPU 面对的只是一个个具备存储能力的地址而已，如果使用高级程序设计的词汇来描述，内存地址就是一个接口，而内存芯片是其中的一种实现；其它的实现例如 [Memory-mapped IO](https://en.wikipedia.org/wiki/Memory-mapped_I/O) 将内存地址映射成 I/O 设备，而 [Memory-mapped File](https://en.wikipedia.org/wiki/Memory-mapped_file) 将一段内存地址空间映射成磁盘上的文件的某一段内容，这样 CPU 就能够像操作内存一样操作 I/O 设备以及文件了。

指令集是 CPU 全部功能的描述，是面向 CPU 进行编程的唯一媒介，所以也叫着机器语言，机器语言是抽象层次最低的编程语言，用二进制表示，其中每个0与1都可以想象成某个精灵在拨动逻辑门中的电路开关，以便让电子信号以预设的轨迹流过整个电路。机器语言是硬件到软件的过渡，从更深刻的意义上看，机器语言刻画的是一个计算模型，而如何合理、高效地使用该计算模型来解决现实之中的问题，我们还需要专门的系统来进行管理与协调，并提供更高层次的抽象模型，这个系统就是操作系统。


# 6. 指令与汇编

本节我们来看如何设计最基本的算术逻辑运算指令，这些指令的运算通过前面章节提到的[16位ALU](/s2e3/3)来完成。我们先回顾一下该 ALU 的示意图：

![16 Bit ALU](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdQXJqxxZBTSPzE2swO%2F-MdWJOMG8AM4GSW0cTcJ%2F16bit_alu.png?alt=media\&token=40294e30-9f36-47a5-a7fb-2439a3855d06)

ALU 通过6个控制位来确定执行何种操作，最多可以支持 2^6=64 种运算，因此理论上我们可以将想要完成的运算依次排列即可，例如规定 000001 执行 x+y, 000010 执行 x-y, 000011 执行 x\&y 等等。这种思路虽然简单直观，但并不适合设计复杂系统。

贯穿全文，我们始终在努力呈现一种方法论：复杂的组件是通过简单的组件构造而成的！这种组件化、模块化的思路是构造大型、复杂系统的核心思想。所以此处我们为 ALU 设计指令时，最好的策略也是通过组合各种更原始的操作，来达成最终的计算效果。所以此处我们让每个控制位负责一个独立的微操作，然后通过组合的方式达成复杂的计算效果。下表是6个控制位的职责：

| Control Bit | 0     | 1                        |
| ----------- | ----- | ------------------------ |
| zx          | -     | x = 0, 将 x 设置为0          |
| nx          | -     | x = !x, 将 x 按位取反         |
| zy          | -     | y = 0, 将 y 设置为0          |
| ny          | -     | y = !y, 将 y 按位取反         |
| f           | x + y | x & y                    |
| no          | -     | out = !out, 将结果 out 按位取反 |

可以将 ALU 的运算过程看着是顺序地执行各个控制位对应的操作，然后得到最终的结果，这样我们能够得到的指令表如下：

{% hint style="info" %}
其实也不是严格意义上的顺序执行，控制位 zx 与 nx 是对输入 x 进行预处理，而 zy 与 ny 是对输入 y 进行预处理，这两个处理是可以并行执行的。
{% endhint %}

| Table 1:         |    |    |    |   |    |        |
| ---------------- | -- | -- | -- | - | -- | ------ |
| ALU Instructions |    |    |    |   |    |        |
| zx               | nx | zy | ny | f | no | out    |
| 1                | 0  | 1  | 0  | 1 | 0  | 0      |
| 1                | 1  | 1  | 1  | 1 | 1  | 1      |
| 1                | 1  | 1  | 0  | 1 | 0  | -1     |
| 0                | 0  | 1  | 1  | 0 | 0  | x      |
| 1                | 1  | 0  | 0  | 0 | 0  | y      |
| 0                | 0  | 1  | 1  | 0 | 1  | !x     |
| 1                | 1  | 0  | 0  | 0 | 1  | !y     |
| 0                | 0  | 1  | 1  | 1 | 1  | -x     |
| 1                | 1  | 0  | 0  | 1 | 1  | -y     |
| 0                | 1  | 1  | 1  | 1 | 1  | x + 1  |
| 1                | 1  | 0  | 1  | 1 | 1  | y + 1  |
| 0                | 0  | 1  | 1  | 1 | 0  | x - 1  |
| 1                | 1  | 0  | 0  | 1 | 0  | y - 1  |
| 0                | 0  | 0  | 0  | 1 | 0  | x + y  |
| 0                | 1  | 0  | 0  | 1 | 1  | x - y  |
| 0                | 0  | 0  | 1  | 1 | 1  | y - x  |
| 0                | 0  | 0  | 0  | 0 | 0  | x & y  |
| 0                | 1  | 0  | 1  | 0 | 1  | x \| y |

> &#x20;注意，在二进制补码中对任意整数 x 按位取反后（即执行 !x 操作），实际得到的数值是 -x - 1, 因为 x + !x = 111….11, 在二进制补码中这是 -1 的编码方式。

我们来看一下 x + 1（对应控制码：011111）的执行过程：

1. zx 为 0, 不对 x 做任何操作
2. nx 为 1, 于是 x = !x, 从数值上来讲此时 x = -x - 1
3. zy 为 1, y = 0
4. ny 为 1, y = !y, 此时 y = -1
5. f 为 1, 所以 out = x + y = -x -2, 最右侧的 x 表示最原始的x输入数值
6. no 为 1, out = !out, 此时 out 的数值为 -(-x - 2) - 1 = x + 1

这样的逻辑拆分极大的简化了电路设计，由于每个控制位都在做一个二选一的操作，这可以通过之前介绍过的 Selector 来控制，完整的电路设计如下图所示：

![ALU Impl](https://4257267501-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MdQXCtxb9g6w1DURwQ9%2F-MdWKlKNQdKW9dQ6SVSt%2F-MdWV_ztxtiNoVK85Kys%2Falu.png?alt=media\&token=58f0026e-896d-4f54-b2c6-a4bbb0f6f324)

图中 ng 可以通过一个 16-1 Selector 来选择 out 的最高位，而 zr 可以通过一个 16 位的或非门实现。

确定了ALU的控制信号之后，我们可以来看一条完整的CPU计算指令还缺哪些方面：

1. 如何指定输入，即 x 与 y \
   CPU 从寄存器取数据是最快的，所以我们可以通过指定两个寄存器的方式来指定输入。寄存器可以有固定的编号，例如如果 CPU 有 8 个通用寄存器的话，可以用三位数字对其进行编码，并且约定 x 在前，y 在后。例如 000001 表示使用编号为 000 的寄存器作为 x, 使用编号为 001 的寄存器作为 y, 如果不需要 y 的话可以只提供 x 的寄存器编号。
2. 如何存放输出，即 out, ng 与 zr \
   计算结果我们可以约定存入 x 的寄存器中，这样可以降低指令长度。ng 与 zr 可以使用固定的方式存入专门的寄存器中（例如一个叫着 FLAGS 的寄存器），在指令中可以不用指定。
3. CPU 如何知道这是一条计算指令 \
   上一节我们提到三类指令：计算类、数据传输类、流程控制类，因此我们可以通过两位数据来进行区分，这里令 00 表示计算类指令、01 表示数据传输类指令、10 表示流程控制类指令。这两位用以区分指令种类，我们可以将其放在指令的最前面

因此我们可以约定计算类指令的格式为：**<指令种类：2位><控制信号：6位><输入 x 与 y 的寄存器编号：3 位或者 6 位>**, 这样的话当 CPU 获取到指令 `00011111000` 时，就会将寄存器 000 中的数字加一。而对指令进行解码、寄存器寻址等操作由 CPU 的控制单元（CU）完成。

机器指令是二进制的，非常不便于人类记忆，我们可以发明一些助记符来帮助编程，即将二进制的指令符号化。例如我们可以将寄存器进行编号：A, B, C等；使用英文单词替换 ALU 的控制符，使其更有语义，例如上述指令可以简称 INC, 这样上述指令就可以写成：INC A, 而加法指令可以写成：ADD A, B. 这种符号化的机器指令叫着汇编语言（Assembly Language），从汇编语言到机器指令的转换由汇编器（Assembler）来完成。

汇编语言不仅仅是机器指令的简单映射，而是基于机器语言的又一次抽象。因为汇编语言需要通过汇编器进行处理，所以我们可以在汇编器中增加更多的功能来支持其他的编程范式，例如使用变量、模块化编程等等。这是让我们脱离硬件思维，开始使用软件架构的思路来看待程序设计的第一步。


