1
2

CPU 0 Store Buffer：x = 1
CPU 1 Store Buffer：x = 2

这两个 Store 能否同时存在？

答案是：

可以同时存在于两个 CPU 各自的 Store Buffer 中；但当它们真正排出并进入共享的 coherent memory system 时，必须由 Cache Coherence 决定先后顺序。

本文只讨论 x86-64 上自然对齐的普通 Store，以及普通 WB（Write-Back）cacheable memory。

本文示例是硬件模型，不表示普通非原子 C/C++ 程序可以直接这样访问共享变量。

Prerequisite

浅谈 x86 的 TSO memory ordering

What

假设初始状态是：

1

x = 0

两个 CPU 同时执行：

1
2
3

CPU 0                       CPU 1

x = 1                       x = 2

每个 CPU 都有自己的私有 Store Buffer。Store 可以先进入本地 Store Buffer，而不需要立即对其他 CPU 可见。

因此，某个时刻完全可能出现：

1
2
3
4
5
6
7
8
9

CPU 0                                      CPU 1
┌───────────────────┐                      ┌───────────────────┐
│ Store Buffer      │                      │ Store Buffer      │
│                   │                      │                   │
│ x = 1             │                      │ x = 2             │
└───────────────────┘                      └───────────────────┘

                    Shared coherent state
                            x = 0

也就是说：

1
2

CPU 0 SB：x = 1
CPU 1 SB：x = 2

可以同时存在。

x86-TSO 可以抽象成每个硬件线程拥有一个私有 FIFO Store Buffer，Store 随后再从各自的 Buffer 传播到共享内存。

为什么不会冲突？

容易产生的误解是：

Cache Coherence 只允许一个 CPU 修改某条 Cache Line，因此两个 CPU 不可能同时保存对 x 的 Store。

这里混淆了两件事：

1
2
3
4
5

Store 位于本核 Store Buffer 中

和

Store 已经获得 Cache Line 的写权限，并对外可见

它们不是一回事。

Store Buffer 是 CPU 的私有结构：

1
2
3
4
5

Store 进入 Store Buffer
        ≠
CPU 已经获得 Cache Line 的写权限
        ≠
Store 已经对其他 CPU 可见

因此，两个 CPU 可以分别暂存：

1
2
3

CPU 0：我准备写 x = 1

CPU 1：我准备写 x = 2

但是，它们不能无序地同时更新共享的 coherent Cache Line。

真正排出 Store Buffer 时，Cache Coherence 会对包含 x 的 Cache Line 进行所有权仲裁。

基础 Example

初始状态：

1

x = 0

两个 CPU 分别执行：

1
2
3

CPU 0                       CPU 1

W(x) = 1                    W(x) = 2

首先，两个 Store 都进入各自的 Store Buffer：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

时间
 │
 ▼

CPU 0                                      CPU 1

Store Buffer：x = 1                        Store Buffer：x = 2
        │                                          │
        │ 尚未全局可见                             │ 尚未全局可见
        │                                          │
        └───────────────┬──────────────────────────┘
                        │
                        ▼
                Cache Coherence 仲裁

此时两个 Store 可以同时处于 pending 状态。

接下来，Cache Coherence 必须决定谁先获得包含 x 的 Cache Line 的写权限。

最终只有两种顺序。

情况一：CPU 0 先排出

假设 CPU 0 先获得写权限：

1
2
3
4
5
6
7

CPU 0 的 x = 1
        │
        ▼
先排出 Store Buffer
        │
        ▼
x = 1 对外可见

随后 CPU 1 获得写权限：

1
2
3
4
5
6
7

CPU 1 的 x = 2
        │
        ▼
后排出 Store Buffer
        │
        ▼
x = 2 对外可见

同一地址上的 coherence order 是：

1
2
3
4
5

CPU 0：W(x) = 1
        │
        │ coherence order
        ▼
CPU 1：W(x) = 2

可以表示为：

1

W0(x = 1) →co W1(x = 2)

最终：

1

x = 2

情况二：CPU 1 先排出

也可能是 CPU 1 先获得写权限：

1
2
3
4
5

CPU 1：W(x) = 2
        │
        │ coherence order
        ▼
CPU 0：W(x) = 1

可以表示为：

1

W1(x = 2) →co W0(x = 1)

最终：

1

x = 1

因此，两个 Store 可以同时位于各自的 Store Buffer 中，但一旦传播到共享 coherent state，同一地址上的 Store 必须形成一个确定的顺序。x86-TSO 相关模型和一致性约束都禁止同一地址上的 Store 处于相互矛盾的全局顺序中。

“串行化”的含义

这里的串行化不是说：

1
2

CPU 0 必须执行完全部指令
然后 CPU 1 才能开始执行

它只表示：

对同一个地址 x 的两个 Store，在 coherent memory system 中必须存在明确的先后顺序。

合法情况是：

1
2
3

x = 1
然后
x = 2

或者：

1
2
3

x = 2
然后
x = 1

不允许存在：

1
2
3

CPU 2 认为：x = 1 在 x = 2 前面

CPU 3 认为：x = 2 在 x = 1 前面

对于同一个内存位置，Cache Coherence 要求相关 Store 被序列化到一致的 coherence order 中。

需要注意：

其他 CPU 不一定真的读取到中间值。

例如实际顺序是：

1

x = 0 -> x = 1 -> x = 2

某个 CPU 可能一直没有读取 x，等它真正读取时只看到：

1

x = 2

但在 coherence order 中，x = 1 仍然排在 x = 2 前面。

排出 Store Buffer 不等于写入 DRAM

这里所说的：

1

Store 排出 Store Buffer

不要简单理解成：

1

数据立即写入 DRAM

对于普通 Write-Back Cache，Store 排出通常意味着：

1
2
3
4
5
6
7

获得包含 x 的 Cache Line 的写权限
        │
        ▼
将 Store 合并到本核的 Cache Line
        │
        ▼
Store 按照 Cache Coherence 规则对外可见

此时最新数据可能仍然位于某个 CPU 的 Cache 中，并没有立即写回 DRAM。

所以，更准确的理解是：

Store 从 CPU 的私有 pending 状态，进入了由 Cache Coherence 管理的共享可见状态。

记忆图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

CPU 0                                      CPU 1

┌──────────────────┐                       ┌──────────────────┐
│ Store Buffer     │                       │ Store Buffer     │
│                  │                       │                  │
│ x = 1            │                       │ x = 2            │
└────────┬─────────┘                       └────────┬─────────┘
         │                                          │
         │       两个 pending Store 可以共存        │
         │                                          │
         └──────────────────┬───────────────────────┘
                            │
                            ▼
                  Cache Coherence 仲裁
                            │
                 ┌──────────┴──────────┐
                 │                     │
                 ▼                     ▼

          x = 1 →co x = 2       x = 2 →co x = 1

              最终 x = 2            最终 x = 1

可以简单记成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

私有 Store Buffer 中：

CPU 0：x = 1
CPU 1：x = 2

可以同时存在。

进入共享 coherent state 时：

x = 1 → x = 2

或者：

x = 2 → x = 1

必须二选一。

总结

双 Store Buffer 场景的核心是：

“同时存在”描述的是两个 CPU 的私有 pending 状态；”串行化”描述的是这些 Store 对共享 coherent state 生效时的全局顺序。

因此：

1
2

CPU 0 SB：x = 1
CPU 1 SB：x = 2

可以同时存在。

但真正排出时，同一地址上的 Store 必须由 Cache Coherence 排成：

1

x = 1 →co x = 2

或者：

1

x = 2 →co x = 1

不会存在两个互相矛盾的全局顺序。

一句话概括：

两个 CPU 可以同时”准备写”同一个地址，但不能无序地同时”完成对外可见的写”；最终由 Cache Coherence 串行化。

参考资料:

1. x86-TSO: A Rigorous and Usable Programmer’s Model for x86 Multiprocessors
2. A Better x86 Memory Model: x86-TSO
3. Intel SDM
4. A Primer on Memory Consistency and Cache Coherence, Second Edition

Overview

FUSE (Filesystem in Userspace) passthrough is a feature designed to improve the performance of FUSE filesystems for I/O operations. Typically, FUSE operations involve communication between the kernel and a userspace FUSE daemon, which can incur overhead. Passthrough allows certain operations on a FUSE file to bypass the userspace daemon and be executed directly by the kernel on an underlying “backing file”.

What

FUSE Passthrough 是一种为 FUSE 文件系统加速数据 I/O 的机制。

普通 FUSE 中，即使 daemon 最终只是读写本地的另一个文件，每次 read()、write() 都需要在内核和用户态 daemon 之间往返：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

应用程序

   │ read/write

   ▼

Linux VFS / FUSE 内核模块

   │ /dev/fuse 请求

   ▼

FUSE daemon（用户态）

   │ pread/pwrite

   ▼

底层文件系统中的真实文件

开启 FUSE Passthrough 后，daemon 可以在打开文件时告诉内核：

这个 FUSE 文件对应底层的哪个 backing file。后续数据读写可以直接访问它，不必再把每个请求发给我。

于是路径变成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

                 OPEN / CREATE

应用程序 ─────► FUSE 内核模块 ─────► FUSE daemon

                                      │

                                      │ 返回 backing_id

                                      ▼

                              底层 backing file

                READ / WRITE / MMAP

应用程序 ─────► FUSE 内核模块 ─────► backing file ─────► 底层文件系统

                         不再经过用户态 daemon

可以把它概括为：

文件系统控制面仍在用户态 daemon，文件数据面可以下沉到内核。

总结

FUSE Passthrough 的核心不是绕过整个 FUSE 文件系统，而是：

1
2
3
4
5
6
7
8

路径、打开、权限、映射和元数据
              ↓
        仍由 FUSE daemon 控制


read / write / splice / mmap
              ↓
      内核直接访问 backing file

它保留了 FUSE 灵活的用户态控制能力，同时避开了高频数据 I/O 的用户态往返开销。

个人总结: 思想类似于vhost

参考资料:

1. AOSP: FUSE passthrough
2. https://docs.kernel.org/: FUSE Passthrough
3. FUSE passthrough for file io

Prerequisite

• DRAM components
• DRAM Chipkill技术
• DDR5 Bounded Fault ECC技术

Overview

Bounded Fault ECC（有界故障ECC）的提出，很大程度上就是为了弥补传统 Chipkill 在 x8 DRAM 组织下无法覆盖某些 device fault 的问题。

核心关系：

Chipkill 本身不是万能的，它依赖 DRAM device 的粒度（x4/x8）。Bounded Fault ECC 的目标就是把”不可控的大故障”限制成 ECC 可以处理的有界故障，从而让 Chipkill 能覆盖更多场景。

下面结合 x4 / x8 解释。

回顾 Chipkill 的基本思想

Chipkill：

将一个 DRAM chip/device 的失效看成一个 ECC symbol 丢失，然后利用强ECC恢复。

例如：

一个 cache line：

1
2
3
4
5

Data:

Chip0  Chip1  Chip2  Chip3
  |      |      |      |
symbol symbol symbol symbol

如果：

1

Chip2 完全失效

变成：

1

symbol2 missing

ECC恢复：

1
2
3
4
5
6
7
8
9

symbol0
symbol1
symbol2  <--- lost
symbol3

        |
        v

ECC reconstruction

因此：

Chipkill要求：device failure必须是ECC可以建模和恢复的symbol error。

x4 DRAM为什么天然适合Chipkill？

x4 DRAM：

表示：

一个DRAM chip一次输出4 bit数据。

例如：

1
2
3
4
5
6
7

x4 DRAM:

Chip0 ---> 4 bits
Chip1 ---> 4 bits
Chip2 ---> 4 bits
Chip3 ---> 4 bits
...

假设一个device坏：

1

Chip2 failure

损失：

1

4 bits

ECC看到：

1

一个symbol丢失

这是比较容易处理的。

所以：

1
2
3
4
5
6

x4 DRAM + ECC DIMM

       |
       v

Chipkill-friendly

为什么x8 DRAM给Chipkill带来问题？

x8 DRAM：

一个chip输出：

1

8 bits

例如：

1
2
3
4

Chip0 ---> 8 bits
Chip1 ---> 8 bits
Chip2 ---> 8 bits
Chip3 ---> 8 bits

如果：

1

Chip2 failure

一次丢：

1

8 bits

问题来了：

ECC symbol粒度通常没有这么大。

也就是说：

1
2
3
4
5

一个device failure

        =

多个ECC symbol同时错误

例如：

1
2
3
4
5
6
7
8

symbol0
symbol1
symbol2
symbol3

Chip2坏:

symbol1 + symbol2同时丢失

传统Chipkill：

1

一个symbol failure

可以处理。

但是：

1

多个symbol failure

可能超出ECC能力。

所以：

传统Chipkill在x8 DRAM下无法保证覆盖整个device failure。

为什么需要 Bounded Fault ECC？

问题本质：

x8 DRAM：

1
2
3
4

device failure
        |
        v
8-bit error burst

这个故障太大。

Bounded Fault ECC的思想：

不要求ECC处理任意大的device fault，而是通过限制fault范围，把错误变成ECC可纠正的形式。

也就是：

1
2
3
4
5
6
7
8
9
10
11

unbounded fault

     |
     v

bounded fault

     |
     v

ECC correction

Bounded Fault ECC如何帮助Chipkill？

简单理解：

以前：

1
2
3
4
5
6
7
8
9
10
11
12
13

x8 DRAM

Chip failure

       |
       v

8-bit burst error

       |
       X

Chipkill无法覆盖

加入Bounded Fault ECC：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

x8 DRAM

Chip failure

       |
       v

fault containment

       |
       v

bounded error pattern

       |
       v

Chipkill ECC can correct

也就是说：

Bounded Fault ECC把x8 device failure转换成Chipkill ECC能够处理的故障模型。

Example

没有Bounded Fault ECC

x8:

1
2
3
4

Chip0 Chip1 Chip2 Chip3

       X

Chip2坏：

1

8 bits corrupted

ECC：

1
2
3

需要恢复8-bit device failure

超过能力

结果：

1

UE

有Bounded Fault ECC

故障：

1

Chip2 failure

经过fault bounding：

1

只暴露有限bit error

例如：

1

错误限制在一个ECC word范围内

然后：

1
2
3
4
5
6

Chipkill ECC

      |
      v

correct

x4、x8与RAS演进关系

可以这样理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

         DRAM device fault

               |
      -----------------
      |               |
     x4              x8
      |               |
      |               |
Chipkill容易     Chipkill困难
      |               |
      |               |
      v               v

传统Chipkill    Bounded Fault ECC
                      |
                      |
                      v

             x8也可以实现
             device fault tolerance

为什么不用全部换成x4？

这是实际工程问题。

x4优势：

• 更容易实现Chipkill

但是：

• DRAM颗粒组织不同
• PCB布线
• 成本
• 容量密度
• 产品兼容性

x8：

• 成本低
• 常见
• 容量密度高

所以业界希望：

保留x8 DRAM优势，同时获得类似Chipkill的可靠性。

这就是Bounded Fault ECC出现的原因。

总结

Chipkill依赖DRAM device故障粒度，而传统Chipkill更适合x4 DRAM。x8 DRAM由于一次device failure会产生更大的错误范围，超过传统Chipkill ECC能力。Bounded Fault ECC通过限制故障范围，将x8 device failure转换为ECC可处理的有界错误，从而让Chipkill类保护能够覆盖x8 DRAM。

Bounded Fault ECC不是替代Chipkill，而是扩展Chipkill能够处理的fault model。

What

RAS Offload 是一种将部分硬件错误处理任务从 CPU 的 SMM（System Management Mode）环境卸载到 BMC 的技术。

Intel Xeon 6 引入BMC RAS Offload：

将部分 RAS error handling 从 SMM 转移到 BMC 环境，从而减少 SMI（System Management Interrupt）的使用。

传统方式：

1
2
3
4
5
6
7

Hardware Error
      |
      v
 CPU / SMM
      |
      v
 RAS处理

RAS Offload：

1
2
3
4
5
6
7

Hardware Error
      |
      v
    BMC
      |
      v
 RAS处理

即让BMC承担部分RAS管理任务，而不是让CPU参与处理。

Why

减少 SMI 对业务性能的影响

传统RAS处理中：

1
2
3
4
5
6
7

硬件错误
   |
   v
触发SMI
   |
   v
CPU进入SMM处理

问题：

• SMI会暂停正常CPU执行
• OS和应用无法控制SMM
• 可能造成 latency spike 和性能抖动

对于：

• 云服务器
• HPC
• AI训练

这种长时间运行业务，SMI影响较大。

RAS Offload后：

1
2
3
4

硬件错误
   |
   v
BMC处理

减少CPU中断和业务扰动。

利用BMC独立管理能力

BMC本身就是服务器的管理控制器：

1
2
3
4
5
6
7
8
9
10
11

      Server

+-------------+
|    CPU      |
|  OS/APP     |
+-------------+

+-------------+
|    BMC      |
| Management  |
+-------------+

特点：

• 独立运行
• 独立供电
• 即使OS异常，也可以工作

因此适合承担：

• 错误收集
• 故障处理
• RAS管理

RAS Offload与BMC的关系

两者关系：

BMC 是 RAS Offload 的执行平台，但 RAS Offload 不是 BMC 本身。

BMC功能包括：

1
2
3
4
5
6
7
8
9
10
11

BMC
 |
 +-- 电源管理
 |
 +-- 风扇控制
 |
 +-- 远程管理
 |
 +-- Firmware管理
 |
 +-- RAS Offload

RAS Offload只是BMC新增的一类可靠性管理能力。

How

简化流程：

1
2
3
4
5
6
7
8
9
10
11
12

       Hardware Error
             |
             v
      Error information
             |
             v
            BMC
             |
     +-------+-------+
     |
     v
RAS decision/action

BMC负责：

• 收集错误状态
• 执行部分恢复动作
• 记录错误信息

避免：

1
2
3
4
5
6
7

Error
 |
 v
CPU SMM
 |
 v
SMI interruption

Intel Xeon 6中支持的RAS Offload能力

Memory / PCIe / UPI Corrected Error (CE) handling

• 收集和处理可纠正错误
• 减少CPU参与

Runtime PPR

运行时触发：

• DRAM坏Row修复
• 将故障Row映射到备用Row

属于memory repair能力。

ADDDC

当DRAM device出现失效趋势：

• 动态增强ECC保护
• 避免device failure导致系统故障

ECS data collection

DDR5 Error Check Scrub相关：

• 收集DRAM错误信息
• 辅助RAS分析

SPD bus recovery

恢复DIMM SPD访问通道：

• 解决SPD/SMBus异常
• 保证DIMM管理信息可获取

RAS Offload vs 传统RAS

总结

RAS Offload 是Intel Xeon 6提出的服务器可靠性增强机制，通过将部分RAS错误处理任务从CPU的SMM环境迁移到BMC，使BMC承担错误管理和恢复工作，从而减少SMI中断对业务性能的影响。

简单理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

过去：

Hardware Error
       |
       v
CPU/SMM处理
       |
       v
影响业务


现在：

Hardware Error
       |
       v
BMC RAS Offload
       |
       v
独立处理，减少CPU干扰

其中：

• BMC = RAS Offload 的执行载体
• PPR/ADDDC/ECS/SPD recovery = BMC可以辅助执行的具体RAS动作

它代表服务器RAS架构从CPU参与故障处理，向独立管理控制器负责可靠性管理的演进。

参考资料:

1. Intel® Xeon® 6 Processors with Performance-cores (P-cores): Reliability, Availability, and Serviceability

What

PPR(Post Package Repair)是一种 DRAM内部的修复(repair)机制，通过备用 Row(spare row)替换故障 Row，使DRAM继续可靠工作。

简单理解：

PPR = DRAM发现某个row永久失效后，把该row映射到备用row。

例如：

1
2
3
4
5
6
7
8
9

DRAM Bank

Row0
Row1
Row2  ----> faulty
Row3

Spare Row0
Spare Row1

执行PPR：

1
2
3
4

Row2  ----------+
                |
                v
           Spare Row0

之后：

1
2
3
4
5
6
7
8
9
10
11

访问 Row2

      |
      v

DRAM内部repair logic

      |
      v

Spare Row0

对上层：

• CPU不知道
• OS不知道
• 应用不知道

访问地址保持不变。

PPR属于Memory Sparing的一种

这里需要特别强调：
PPR不是独立于Memory Sparing之外的技术，而是Memory Sparing的一种具体实现。

层次关系：

1
2
3
4
5
6
7
8
9
10

Memory Sparing
       |
       +----------------+
       |                |
 DRAM内部Sparing    System级Sparing
       |                |
       |                |
      PPR          Rank/DIMM Sparing
       |
   Spare Row

所以：

• PPR：row级memory sparing
• Rank sparing：rank级memory sparing

Why

DRAM故障通常是局部永久故障

DRAM长期运行后可能出现：

• bad cell
• bad row
• weak row

错误趋势：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

正常

 |
 v

Correctable Error增加

 |
 v

Row failure

 |
 v

Uncorrectable Error

如果不处理：

1
2
3
4
5
6
7

Bad Row
   |
   v
UE
   |
   v
系统故障

PPR提供：

1
2
3
4
5
6
7
8
9
10
11

发现坏Row

    |
    v

替换Row

    |
    v

继续运行

ECC无法解决所有DRAM故障

ECC主要解决bit error

例如：

1
2
3
4
5
6

single bit flip

       |
       v

ECC correction

但是整个Row失效属于更大粒度故障：

1
2
3
4

Row failure
     |
     v
ECC能力不足

因此需要：

• ECC：纠错
• PPR：修复/替换坏资源

How

PPR依赖三个部分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

       CPU

        |
        |
Memory Controller

        |
 DDR Command

        |
        v

      DRAM

 +-------------+
 | Repair Logic|
 | Spare Rows  |
 +-------------+

 Bad Row
    |
    v
Spare Row

Step 1:发现故障Row

来源可能包括：

• ECC error统计
• Memory Patrol Scrub
• DRAM内部检测
• RAS软件策略

例如：

1
2
3
4

Bank 3
Row 100

CE数量持续增加

判断：

1

Row 100可能永久故障

Step 2:发送PPR命令

Memory Controller发送repair command：

1

Repair(Row100)

DRAM内部：

1
2
3
4

Row100
   |
   v
Spare Row

建立映射关系。

Step 3:后续访问自动重定向

之后：

1
2
3

CPU访问：

Bank3 / Row100

实际：

1

Bank3 / Spare Row

软件无感知。

分类

Intel Xeon 6 RAS文档中提到：

supports both runtime soft Post Package Repair (sPPR) and power-up hard Post Package Repair (hPPR)

也就是说：

• sPPR：运行时修复
• hPPR：启动阶段永久修复

Hard PPR (hPPR), for a permanent row repair, and Soft PPR (sPPR), for a temporary row repair.

hPPR

特点：永久修复

流程：

1
2
3
4
5
6
7
8
9
10
11

PPR

 |
 v

Repair information写入非易失存储

 |
 v

Power cycle后仍有效

适合：

• 永久坏row
• 长期修复

sPPR

特点：临时修复

流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行期间发现坏row

       |
       v

建立临时repair mapping

       |
       v

继续运行

       |
       v

掉电失效

适合：

• runtime recovery
• 临时避免故障

PPR和Memory Sparing区别

二者关系：

PPR是Memory Sparing的一种。

区别主要在粒度：

PPR vs ADDDC vs Chipkill

它们解决不同问题：

1
2
3
4
5
6
7
8
9

             DRAM Reliability

                   |
    --------------------------------
    |              |              |
   ECC          ADDDC           PPR
    |              |              |
bit error     device fault     row failure
correction    correction        repair

简单理解：

总结

Post Package Repair（PPR）是DDR5时代重要的DRAM RAS技术，本质是一种row-level Memory Sparing：当DRAM某个row出现永久故障时，利用备用row建立地址重映射，使坏row被透明替换，从而避免故障升级为系统错误。DDR5进一步支持sPPR（运行时临时修复）和hPPR（永久修复）。

参考资料:

1. Unification of RAS feature control - Enhancing EDAC
2. Intel® Xeon® 6 Processors with Performance-cores (P-cores): Reliability, Availability, and Serviceability
3. Micron® DDR5 SDRAM: New Features
4. Post Package Repair (PPR) Types and SEL Events on Purley and Whitley Platforms
5. Post Package Repair (PPR)

What

ADDDC 是一种针对 DRAM device（DRAM 芯片级故障）的自适应 ECC 保护技术。

核心思想：

Memory Controller 监测到某个 DRAM device 存在失效风险时，动态启用更强的 ECC 保护能力，使系统能够容忍该 device 失效，避免系统崩溃。

简单流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

正常运行
   |
   v
普通ECC保护
   |
检测到device错误趋势增加
   |
   v
开启 ADDDC
   |
   v
增强ECC保护
   |
device最终失效
   |
   v
系统继续运行

Why

DRAM device 故障通常有演进过程

实际服务器中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

正常DRAM

   |
   v

Correctable Error (CE) 增加

   |
   v

Device退化

   |
   v

Device Failure

   |
   v

Uncorrectable Error (UE)

如果等到 device 完全失效：

1
2
3
4
5
6
7

Device failure
      |
      v
ECC无法恢复
      |
      v
系统故障

因此需要提前发现风险，并提升保护能力。

为什么不一直使用 Chipkill？

Chipkill 同样可以容忍 DRAM device 故障。

但是 Chipkill 的问题：

持续性能开销

Chipkill 需要一直运行更强的 device-level ECC：

1
2
3
4
5
6
7
8

普通ECC:

bit error correction


Chipkill:

device failure correction

因此 Memory Controller 需要：

• 更复杂ECC decoder
• 更复杂的数据重构逻辑
• 更高的访问处理复杂度

结果：

• ECC decode latency增加
• memory access path更复杂
• 功耗增加

即：

即使DRAM完全健康，也一直支付高可靠性保护成本。

ECC资源/容量开销无法避免

Chipkill需要更多ECC冗余：

• 通常采用 x4 DRAM organization
• 需要更多ECC symbol

因此：

• DIMM有效容量利用率降低
• ECC开销增加

这一点 ADDDC无法消除。

ADDDC主要优化的是性能开销，而不是ECC容量开销。

How

ADDDC主要由Integrated Memory Controller(IMC)实现。

架构：

1
2
3
4
5
6
7
8
9
10

            CPU

             |
             |
Integrated Memory Controller
             |
       ECC / RAS Logic
             |
             |
           DRAM DIMM

Step 1：监测 DRAM device 错误

Memory Controller统计：

• Correctable Error (CE)
• device错误趋势

例如：

1
2
3
4
5
6

Chip3:

CE:
10
100
10000

判断：

1

Chip3可能即将失效

Step 2：动态切换保护模式

正常：

1
2
3

Normal ECC

低开销

发现风险：

1
2
3
4

Normal ECC
      |
      v
ADDDC mode

切换到更强 ECC 保护。

Intel 文档强调：

The dynamic nature of the operation makes the performance implications material only after the DRAM device is detected to be failing.

含义：只有检测到 DRAM device 正在失效后，ADDDC带来的性能影响才出现。

Step 3：device失效后仍可恢复数据

例如：

1
2
3
4

DRAM:

Chip0 Chip1 Chip2 Chip3
                 X

ADDDC：

1
2
3
4
5
6
7
8
9
10
11

Chip3 failure

       |
       v

ECC reconstruction

       |
       v

Correct data

避免：

1
2
3
4

DRAM device failure
        |
        v
System crash

ADDDC vs Chipkill

简单理解：

1
2
3
4
5
6
7
8
9

Chipkill:

一直穿防弹衣


ADDDC:

平时轻装运行
发现危险再穿防弹衣

ADDDC vs Memory Sparing

总结

ADDDC 是一种预测驱动的 DRAM RAS 技术：Memory Controller 通过监控 DRAM device 错误趋势，在 device 即将失效时动态提升 ECC 保护能力，使系统能够容忍 device 级故障。

相比 Chipkill：

• ADDDC不能消除ECC容量开销
• 优势在于避免Chipkill长期开启带来的性能开销
• 只有检测到故障风险时才进入高保护模式

演进关系：

1
2
3
4
5
6
7
8
9
10
11

普通ECC
   |
   v
Chipkill
(一直高保护，高可靠，高成本)

   |
   v

ADDDC
(预测故障，按需增强保护)

ADDDC 的核心价值就是：用故障预测换取更低的长期性能成本。

参考资料:

1. Intel® Xeon® 6 Processors with Performance-cores (P-cores): Reliability, Availability, and Serviceability
2. New Reliability, Availability, and Serviceability (RAS) Features in the Intel® Xeon® Processor Family

Prerequisite

• DRAM components

Overview

• Memory sparing is a repair function that replaces a portion of memory (spared memory) with a portion of functional memory at that same DPA.
• Cacheline/row/bank/rank memory sparing replaces full cacheline/single DDR row/entire bank/entire DDR rank respectively.

DPA

DPA（Device Physical Address）是内存设备内部看到的物理地址。

CPU/OS访问的是System Physical Address（SPA），经过 Memory Controller 的地址映射后，转换成DRAM设备地址：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

CPU / OS
   |
   |  System Physical Address (SPA)
   |
   v
Memory Controller
   |
   | Address Mapping
   | (Channel / Rank / Bank / Row / Column)
   |
   v
DRAM Device
   |
   | Device Physical Address (DPA)
   |
   v
Memory Cell

简单理解：

• SPA：软件看到的地址
• DPA：DRAM硬件看到的位置

Memory Sparing中的：

“replace … with functional memory at that same DPA”

意思是：

对外暴露的设备物理地址保持不变，只是这个DPA背后的实际存储资源发生替换

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

DPA = Rank0 / Row100

原来:

DPA
 |
 v
坏 Row100


Sparing后:

DPA
 |
 v
Spare Row

对OS和应用透明。

What

Memory Sparing是一种利用备用内存资源替换故障内存区域的RAS技术。

核心思想：

1
2
3
4
5
6
7

发现故障区域
      |
      v
地址重映射
      |
      v
备用区域接管