研究一下 CPU 除法

在  QQ 群 里，    我 让 网友 馥岚过野  出题 来 考 我，

 

馥岚过野  说 ：

“

你昨晚又说做汇编了

我问你几个问题：

目前CPU整数乘法和除法的性能差别在多少左右？

32位乘法和64位乘法有什么差别？

整数乘法时，大数和小数有没有区别？

”

 

 

2021-08-11  接着写  。

 

要 回答  这些问题，  我们先来 研究一下  计算机 的 除法 是 怎么实现 的  。

 

除法 就是 做 减法，  试商 一位，  除数 乘以 这一位 商，  由 被除数 来 减，   差 为 余数，   再 试商 下一位， 同样，  除数 乘以 这一位 商，  由 余数 来 减，    如此重复  。

 

这个 过程 用 逻辑电路  可以 实现 出来 ，   比如 ：

                     

 

 

这个  计算过程 的 逻辑电路 可以设计 出来，   最 简单 的 设计 ，   每个 时钟周期 作 一次 试商，  比如 先 试商 1，  如果 1 乘以 除数 ， 比 被除数 对应 的 前几位 小， 或 比 添位 后 的 余数 小，  则 试商 成功， 否则 试商 0  。

 

二进制 比较 简单，   每一位 最多 只要 试商 2 次，   0 和 1  。   也就是说，  每一位 最多 需要 2 次 试商，  也就是 2 个 时钟周期  。

 

对 被除数  的 每一位 最多 要 试商 2 次，    要 2 个 时钟周期，    能不能 在 一个 时钟周期 里，  就 完成 这 2 次 试商 ？

 

可以 。     这 可以用 组合逻辑电路 实现，   不用 时序逻辑电路，    也就是说，  除法  对 一位 的 （最多两次） 试商 都可以 由 一个 组合逻辑 电路 来 实现，   也就是在 一个  时钟周期 里 完成  。     这里 的 试商 包括了   试商 * 除数 再由 被除数（余数） 来 减 的 整个过程  。

 

这个 组合逻辑电路 的 模块电路图  可以 这样画 ：

                 

 

 

这样，     每一位 的 （2 次）试商 可以 在 一个 时钟周期 里 完成  。

 

一个 8 位 的 二进制数，   除以一个 8 位 以内 的 二进制数，  看起来 要 对  8 个 位 试商  。

 

一开始，    第 1 次 试商 的 时候，    被除数 和 除数 * 试商  的 最高位 要 对齐，  再相减  。

 

之后，    余数 和 除数 * 试商  则 是  从 最低位 对齐，  再相减  。

 

实际上，    余数 要 添位 之后 才会和 除数 * 试商 相减  。   添位，  就是 给 余数 添上 当前 试商 的 被除数 的 那一位  。

 

有时候，     也 不用 添位，    直接 在 当前 试商 的 位 补 0  就行  。

 

为了叙述简便，    余数  添位 后 仍然 简称 余数，    大家 自行 理解 即可  。

 

 

使用 上面 这个 组合逻辑电路，    对 每一位 的 试商  需要 一个 时钟周期，   对  8 位 试商 需要  8 个 时钟周期，   也就是 做完一次 除法 需要  8 个 时钟周期  。

 

以此类推，   16 位 二进制数 的 除法 要  16 个 时钟周期，    32 位 的 除法 要  32 个 周期，    64 位 的 除法 要  64 个 周期  。

 

加法 减法 乘法 都 只要一个 时钟周期 ，    看起来 除法 成了   工作量  “大户”  了  。

 

能不能 缩短一些 时间，   也就是 减少一些 时钟周期 ？

 

能不能 在 一个 时钟周期 内  做完  8 位 的 试商  ？

 

可以，   同样，   这也就是用 一个   组合逻辑电路 来 完成 对 8 位 的 试商，    画 一个  模块电路图 ：

                     

 

 

这个 图 没有 画完，  只 画 了 2 层  试商模块，  1 层 试商模块 负责 对  1 位 试商，   8 位 就要  8 层 试商模块  。

 

看的出来，   第 1 层 试商模块 是 2 个，   第 2 层 的 试商模块 个数 是 第 1 层 的 2 倍，   是 2 * 2 = 4 个，  下一层 是 上一层 的 2 倍 ，  也就是，

 

第 3 层 的 试商模块 个数 是  2 ³ = 8 个，

第 4 层 的 是  2 ⁴ = 16 个，

第 5 层 的 是  2 ⁵ = 32 个，

第 6 层 的 是  2 ⁶ = 64 个，

第 7 层 的 是  2 ⁷ = 128 个，

第 8 层 的 是  2 ⁸ = 256 个，

 

全部加起来 就是    2 + 4 + 8 + 16 + 32 + 64 + 128 + 256 = 512  个 试商模块  。    512 = 2 * 2 ⁸ ，    也就是   2 * 2 ⁸  个 试商模块 。

 

也就是，    n 位 二进制 整数 的 除法 要在 一个 时钟周期 里 完成，   需要   2 ^ ( n + 1 )  个 试商模块  。

 

这个 数量 是 很大的，    16 位 时，    2 * 2^16 = 131072  ≈  13 万 ，      32 位 时，   2 * 2^32 = 8 G  ≈  80 亿   。

 

13 万 个 试商模块，     这么多 电路元件  只是用于 除法，   这个 电路规模 是 很大 的，    80 亿 那就 更夸张 了  。

 

可以看到，    要想 在 一个 时钟周期 里 完成 比较多 位 的 除法，    需要 一个 规模 很大 的 组合逻辑电路 ，   规模 很大 就是 元件数量 很多  。

 

这些 与 硬件工艺 硬件资源 硬件成本  相关 。

 

总之 呢 ，   一个 时钟周期 完成 32 位 除法 是 不现实 的，     16 位 可能 也 够呛 ，   那么，  能不能 折中一点，    比如 一个 时钟周期 完成 4 位 除法，  这样，  8 位 除法 就是 8/4 = 2 个 周期， 16 位 除法 是 16/4 = 4 个周期，   32 位 除法 是 32/4 = 8 个周期，   64 位 除法 是 64 / 4 = 16 个 周期  。

 

应该 可以 这样做 ，  哈哈  。

 

 

上面的 是 基本 的 除法，   也可以说是 整数除法，    再来 看看  浮点数 的 除法  。

 

比如，   1001 / 0.0011 ，      首先 要 对齐 被除数 和 除数 的 小数点 ，  就是 把 被除数 和 除数 都 转换成 整数，    1001 / 0.0011 = 10010000 / 11 ，

 

1001 / 0.0011    会 转换成    10010000 / 11     来 计算  。

 

1001 是 4 位，  转换成  10010000 ，  就成了 8 位，  需要 8 位 的 存储单元 和 运算电路  。

 

对 二进制 来说，   余数 比 除数 至少 要 少一位，    如果 除数 是 4 位，  则 余数 可能是 3 位 、2 位 、1 位 、0 位  。

 

当然，    如果 试商 是 直接 补 0 ，   试商 * 除数 = 0 * 除数 = 0，    余数 - 试商 * 除数 = 余数 - 0 = 余数，    余数  还是 保持不变，    此时，  余数 也可能 和 除数 的 位数一样，  也就是，   余数 也可能 是 4 位  。

 

试商模块 处理 余数添位 和 余数 - 试商 * 除数，  余数 最多 4 位， 除数 最多 4 位 ；    试商 是 1 位，  二进制 的 话，   试商 只会 是 1 和 0 ，    试商 * 除数 也 只会 等于 除数 或  0，   也就是  试商 * 除数 最多 4 位，   所以 ，  试商模块 最多 只要 处理  4 位 数据 就可以，    也就是说，  试商模块 只要 4 位 电路 就可以 。

 

8 位 电路 应该 主要 是 存储 被除数 和 商 的 电路  。    但 4 位数 的 除法，   商 似乎 也 是 4 位，   所以，  商 似乎 也只要 4 位 的 存储单元  。

 

如果 是   1001 / 0.00000011  ，   那要 转换成  100100000000 / 11  ，   被除数 1001 要 变成   100100000000 ，    一个 12 位 整数，   需要  12 位 的 存储单元  。

 

实际 的 CPU 的 电路位数 是 有限 的，   设计 的 时候 会 决定 电路位数，   这 会对  浮点数 的 （大数）除法  精度 产生 相应 的 影响  。

 

比如，   电路 支持 的 位数 是 4 位，    则   1001 / 0.0011  转换成   10010000 / 11  ，    如果 被除数 的 存储单元 只有  4 位， 就 只会 存储  10010000  的  高 4 位 1001 ，  于是，  实际 的 除法 只会 做到 前 4 位 1001 除以 11，  商 的 后面位数 可能 直接 补 0  。

 

补 0 的 部分 和 实际 的 商 之间 就会 有 差，   这个 差 就是 丢失 的 精度  。

 

当然，   10010000 / 11   刚好 前 4 位  1001 / 11 = 11  就 可以 除尽， 后面 确实 补 0 就可以，  但 这 只是一个 例子，   如果 前 4 位 除不尽，  那  补 0 的 部分 和 实际 的 商 之间 就会 有 差 了  。

 

所以，  32 位 的 除法电路 的 被除数 存储单元 不一定 只有 32 位，   可能 是 更多位，   这样 可以 在 浮点数 大数除法  时 减少 精度丢失  。

 

 

小朋友们，   看了 上面的 计算机 除法 基础知识，    应该可以回答 开头 的 问题 了 吧  ？

 

等，   我现在 才 发现 ，   开头 的 3 个 问题 中，   只有 一个 提到了 除法，        这  ？

 

我 记得 看了 好几遍 题目 ，     这是 怎么回事  ？

 

 

我 提倡 用  模块电路图 + 模块规格  来 做  硬件电路 设计，     真的很爽，  爽死了，  无敌  。

 

模块规格 包括   模块 定义 、接口 、参数 等  。