CPU 应该 搞 0 级 Cache ， 而不是 大寄存器

CPU 应该 搞 0 级 Cache ，  而不是 大寄存器  。

 

具体的说，   是 CPU 应该 搞  精简指令集 RISC  和   0 级 Cache ，    而 不是 大寄存器   。

 

0 级 Cache 也可以称为   L0 Cache   。

 

0 级 Cache 是 离 CPU 最近 的 Cache，  访问 只需要 1 个 时钟周期，   和 寄存器 一样  。

 

那  0 级 Cache  和 寄存器 有 什么 区别  呢   ？

 

0 级 Cache  在 内存 地址编制 内，  和  一级 Cache 、二级 Cache 、三级 Cache 、内存 在 一个 统一 的 地址空间 里，  按 统一 的 地址管理  。

 

而 寄存器 是 不在 内存 地址编制 里 的    。

 

0 级 Cache  从 下级存储 （一级 Cache 、二级 Cache 、三级 Cache 、内存）   载入载出 哪些 数据 是 完全 由 程序员 控制 的，  具体的， 是 完全 由 程序员 用 汇编指令控制的  。

 

这是 和   一级 Cache 、二级 Cache 、三级 Cache   的 不同  。

 

一级 Cache 、二级 Cache 、三级 Cache   载入载出  哪些 数据 是由  CPU 自己决定的， 比如 根据 命中算法，  程序员 无权干涉  。

 

程序员 用 指令  map_in   将 内存（一级 Cache 、二级 Cache 、三级 Cache） 地址 和 数据 映射 进  0 级 Cache ，   如果 0 级 Cache 里 的 存储单元 原来已经 映射 了 地址 和 数据，  此时 将 新的 地址 映射 到 这个 存储单元，   则 旧 的 数据 将 替换 为 新 的 数据，  旧 的 映射地址 将 映射 成 新 的 地址，   如果 旧 的 数据 被 修改过，  则 要 先 写回 对应 的 内存（一级 Cache 、二级 Cache 、三级 Cache） 地址  ，  这 称为 map_out ，     也可以称为  载出  。

 

map_in  也可以 称为 载入  。

 

 

0 级 Cache 的 好处 是 ：

 

1    指针取值（ * 指针） 和 指针字段（ 指针 -> 字段  ） 可以 享有 和 局部变量 一样 的 寄存器优化 的 待遇 

      寄存器优化 就是 把 常用 的 数据 存在 寄存器 里 反复使用  。

      在 寄存器 架构下，   指针取值（ * 指针） 和 指针字段（ 指针 -> 字段  ）   不容易 做 寄存器优化，  因为 指针 会 改变，    * 指针 和  指针 -> 字段  会 随 指针 的 改变 而 改变，

      同时，   * 指针 和  指针 -> 字段   可能 被 其它 同样指向这个 地址 的 指针 修改，  比如 指针2 和 指针 相等，    * 指针2 和 指针2 -> 字段 修改 的 数据 就是  * 指针 和  指针 -> 字段  的 数据，    但是  * 指针 和  指针 -> 字段  并不知道 数据 被 修改   。

      这还只是  单线程 的 情况   。

      多线程 也会 造成 类似 的 数据 不一致 的 情况   。

      但 使用 0 级 Cache 的 话，   0 级 Cache 是 按 地址 访问 的，  和  一级 Cache 、二级 Cache 、三级 Cache 、内存  同在一个 地址编制 ，   对于 指针取值（ * 指针） 和 指针字段（ 指针 -> 字段  ），   都是 按 地址访问，   不用 担心 数据不一致 的 问题   。   而  访问  0 级 Cache 的 时间 是  1 个 时钟周期，   和 寄存器 一样快  。

 

2    多核 数据同步 和 单核多线程 并发 数据一致

      这 其实 是 第 1 点 里 说 的 多线程 的 情况，   对于 多核 的 共享数据，  修改 时 要 mutex 并 同步到 各 核 的 Cache，  在 寄存器 架构下，  对于 需要 实时同步 的 多核数据， 是 不能 做  寄存器优化 的，   也就是 要 禁用 寄存器优化，   比如 C++  里 的 atomic<T> 原子类型 是 禁用 寄存器 优化 的  。

      而 现在 用  0 级 Cache，   就不存在这个问题，    0 级 Cache 和 现在 的 1 级 Cache 一样，  修改 原子数据  时 直接 mutex 和 通知 其它 核 同步，

      这样 会不会 影响性能 ？ 

      不会  。    读取 时 仍然 是   1 个 时钟周期 ，   修改 时 会 发起 mutex ，  mutex 要 通知 到 其它 核 ，   当然 需要 一些 的 时钟周期，    另外，  若 收到 其它 核 已 改写数据 的 通知，   要从 其它 核 的 Cache 里 把 数据 同步过来，    这 也要 一些 时钟周期   。

      当 收到 其它 核 发起 mutex 的 通知 时，   会 等待 其它 核 的 mutex 结束，  这 需要 等待一些 时钟周期  。

      除此以外，  读取 时 是   1 个 时钟周期   。   也就是说，   如果  自己 不改写，  也 没有 收到 其它 核 mutex 和 改写 的 通知，   读取 0 级 Cache 里 的 原子变量 是  1 个 时钟周期，   和 普通变量 一样   。

 

      对于 单核多线程 并发 共享数据，   要 保证 数据 在 并发中一致，  也要 禁用 寄存器优化，   同理，   用  0 级 Cache，    就不存在这个问题    。

 

3    编译器 / 程序员   不用 考虑 把 寄存器 里 的 数据 写回 Cache / 内存   

      在 寄存器 架构下，   常用 的 数据 存在 寄存器 里 反复使用  ，  用完后（比如 函数 结束时），  如果 数据 被 修改 过，  要 写回 Cache / 内存 ，

      用  0 级 Cache  就 不用 编译器 / 程序员 考虑 这件事 了   。

      0 级 Cache 会 记录 哪些 数据 被 修改过，  被 修改 的 才 写回 映射 的 内存地址（当然， 实际上 可能 是 写 Cache ， 也可能写 内存），

      这 需要  0 级 Cache 的 硬件电路 将 被 修改过的 存储单元 标记 为  “被修改” ，

      对于 这一点，   硬件电路 很容易 做到  。

 

      事实上，  在 0 级 Cache 里，  程序员 也不用 考虑 在 什么 “时机” 把 数据 写回   一级 Cache （ 二级 Cache 、三级 Cache 、内存 ），

      因为  0 级 Cache 也是 Cache，  和   一级 Cache 、二级 Cache 、三级 Cache 、内存  本身 就是 一个 体系 ，

      就好像 程序员 不用 考虑   一级 Cache 的 数据  “写回”  二级 Cache 、三级 Cache 、内存   。

 

      “时机”  比如 上面说的  “用完后（比如 函数 结束时）”   ，     在 0 级 Cache 里，  程序员 也不用 考虑  这些   。

 

       程序员 只要 考虑 把 哪个 （需要的） 地址 映射 到  0 级 Cache 的 哪个 存储单元，   这个 存储单元 原来 的 数据 如果 修改过的话， 会 自动写回 映射 的 地址  （ 一级 Cache 、二级 Cache 、三级 Cache 、内存 ）   。

 

4     访问 0 级 Cache  只要 一个 时钟周期， 和 寄存器 一样 。  如果  指针 和  * 指针 都 存 在 0 级 Cache 里，  则  * 指针 一个 时钟周期 就可以 完成，  也就是说 读写 * 指针 一个 时钟周期 就可以 完成  。  读写 指针 -> 字段 也可以 一个 时钟周期 完成  。

        实际上，  只要 电路 的 精度 可以，   * * 指针 ，  指针 -> 字段 -> 字段  也可以 一个 时钟周期 完成 ，    甚至，   * * * 指针 ，  指针 -> 字段 -> 字段 -> 字段  也可以 一个 时钟周期 完成  。

        * * * 指针 ，  指针 -> 字段 -> 字段 -> 字段 ，     要把 指针 的 多次连续访问 放到 一个 时钟周期（指令） 里，   则 指针 的 连续访问次数 越多，  指令 的 电路元件 越多，  元件 数量 随 访问次数 正比增加  。  而 电路精度 越高，   比如  5nm、7nm，   在 同样 的 芯片面积 上，   可以 设计制造 更多的 元件  。

 

5     在 寄存器 架构 下，   可以 将 对象 的 一些 字段（比如 数组 首地址  、Length）  复制 一个 副本 到 局部变量 里 （栈 里） ，   然后 再对 副本 对应 的 局部变量 进行 寄存器优化， 也就是 把 副本 对应的 局部变量 放到 寄存器 里 反复使用 ，   说白了，  就是 把 副本 放到 寄存器 里 反复使用 ，    这是一种 寄存器优化 ，    这种 优化 方式 叫做   “Local Agent”  ，  副本 就是 Local Agent  。

       Local Agent 的 方式 需要 注意一个 问题，  如果 副本 对应 的 对象字段  发生了 改变，   则 要 考虑 把 这个 改变 同步 到 副本，  或者 即使不同步，  仍然 接着 使用 副本，也不会 产生 程序逻辑问题  。

      在  0 级 Cache 架构 里 ，  如 第 4 点 所说，    * 指针 和 指针 -> 字段   都可以在 一个 时钟周期 完成，   也就 不需要  Local Agent 优化 了，   也就不存在 Local Agent （副本） 和 对象字段 的 同步  。

 

   

上面说了 大半天，   由 程序员 用 汇编指令 map_in 和 现在 的 用 汇编指令 把 数据 读入寄存器 是 类似的，  还是 一套做法  。   我后来想了一下，     这 完全 没必要  。   可以 由  CPU 直接将 指令 （比如 加法指令） 中 用到 的 数据  从 内存（一级 Cache）  读入（map_in）  到  0 级 Cache  就行 。   这个 做法 就 彻底 了，   相比 现有的 寄存器 架构，  这个 做法 改革 的 就 彻底 了 。     CPU 可以用 流水架构 提前 将 接下来 的 指令 里 要用到 的 多个 数据 （并行的） map_in  到 0 级 Cache  ，   这样 就 OK 了，  很 简单， 很 清楚  。

 

这个 设计 极大 的 简化了 编译器 的 工作 ，   极大 的 简化了 编译器 的 设计 和 编写 ，     因为 编译 的 一个 主要工作 寄存器布局 和 内存屏障 都 不需要 考虑 了，   这 非常爽，  轻松到 要  飞起来  。     真的 不得了 。

 

 

在  QQ 群 里 讨论 本文 时，  我说   “静态约束搞死人，  动态判断一句话  。”

 

静态约束 是指 编译时 通过 语法 约束 让 程序 满足 某些要求 ；    动态判断 是指 在 程序 运行时 判断 程序 是否 满足 某些要求，  若 不满足 则 抛出异常  。

 

动态判断 类比  CPU 用一些 统计算法 决定 哪些 数据块（Cache Line） 从 一级 Cache 载出到内存（三级 Cache），  哪些 数据块（Cache Line） 在 一级 Cache 多呆一些时间，  可能 比较少 用到 的 数据 优先 载出，  可能 比较多 用到 的 数据 在 一级 Cache 多呆一些时间 ；     从 0 级 Cache 载出 数据 到 一级 Cache 也是一样  。

 

静态约束 类比 编译器 构思 寄存器布局 和 内存屏障，    也就是 编译器  要 具体 的 给出 每一个 数据 的 读入 寄存器 和 从 寄存器 写回 一级 Cache 的 方案  。

 

显然，    编译器 构思 寄存器布局 和 内存屏障  的 做法 精准 到 每一个 数据 的 读入 写出，    但是 构思 这些 很费脑筋，  当然 你会说 这是 编译器 构思，  不用人去构思，  但 人 要 构思 能做 这个  构思 的 算法，   也就是 人 要 教会 让 编译器 如何 做 这个 构思，    这 也是 很费脑筋，  颇为艰深  的  。

 

而  CPU 动态 的 统计判断 数据 的 使用率 来 决定 载出 哪些 数据（块），   这 有 概率统计 的 成分，   但是 简单易行，   人 不需要 考虑 太多东西  。

 

 

我提倡 用 模块线路图 来 设计 硬件电路，     硬件电路 本来 就是 模块化 的 ，  用 模块线路图 设计 很适合 。   模块 的 规格，  包括 接口 和 电路参数 作为 模块 的 说明书 单独说明 就好   。

 

其实 设计 CPU 很简单，      主要 是  制造工艺  和   电路计算 比较难   。

 

精简指令集 RISC   和   0 级 Cache   的 架构 称为     RISC-L0-Cache 架构 ，   也称为  L0 Cache 架构 ，   简称  L0 架构   。

 

为什么 会 写 这篇 文章 ？         写 这篇 文章 的 原因 是 最近（2021-03-26） 一直 在 搞  K-GC / D++ ，   K-GC / D++  是 ILBC 的 一个 子项目 ，  里面 涉及 到 很多  多核数据同步 和 寄存器优化 的 问题 和 设计，   然后 前几天 又看到 民科吧 的 一个 帖 《民科们速速进来学习》  https://tieba.baidu.com/p/7273181457  ，      大致内容如下，     就想到了  0 级 Cache 的 想法  。