WEBVTT

1
00:00:00.102 --> 00:00:03.992
一段很长的上下文，模型已经算过一次了。

2
00:00:04.433 --> 00:00:07.988
下一次遇到相同前缀，能不能直接复用？

3
00:00:08.441 --> 00:00:12.885
可以，但先要回答一个更实际的问题：这些缓存，

4
00:00:12.938 --> 00:00:14.045
到底放在哪儿？

5
00:00:14.485 --> 00:00:15.707
看一个量级。

6
00:00:16.160 --> 00:00:20.333
假设每个 token 需要一百二十八 KiB 的 KV Cache，

7
00:00:20.541 --> 00:00:23.942
那么十三万左右的 token，就接近十六 GiB。

8
00:00:24.381 --> 00:00:28.967
六十四份互不共享的上下文，合起来大约是一 TiB。

9
00:00:29.407 --> 00:00:32.936
显存要留给模型和正在执行的请求，

10
00:00:33.119 --> 00:00:36.171
主机内存也有成本和容量上限。

11
00:00:36.624 --> 00:00:41.429
本地 NVMe SSD 适合留住更多可能复用的缓存，

12
00:00:41.495 --> 00:00:46.313
而 GDS，解决的是怎样把它们高效送回 GPU。

13
00:00:46.765 --> 00:00:50.050
下面，我们按重构已经合入的结构，

14
00:00:50.168 --> 00:00:54.521
沿着缓存服务的多进程读写路径，一层一层拆开。

15
00:00:54.974 --> 00:00:57.047
先看硬件，再看代码，

16
00:00:57.204 --> 00:00:59.715
最后用 Phoenix backend 说明，

17
00:00:59.936 --> 00:01:02.576
这套设计怎样接入新的实现。

18
00:01:03.028 --> 00:01:08.645
普通读取常见的路径，是先把 SSD 的数据放进主机内存，

19
00:01:08.711 --> 00:01:10.127
再复制到显存。

20
00:01:10.580 --> 00:01:13.619
这里的主机内存，是数据中转站。

21
00:01:14.072 --> 00:01:17.241
GDS 要省掉的，正是这一步中转。

22
00:01:17.693 --> 00:01:20.295
但这不意味着 CPU 消失了。

23
00:01:20.735 --> 00:01:25.063
用户态程序决定读什么、读多少、放到哪里；

24
00:01:25.335 --> 00:01:29.573
内核和驱动处理权限、文件位置与设备映射。

25
00:01:30.026 --> 00:01:34.496
用户态和内核态的代码，仍然都运行在 CPU 上。

26
00:01:34.936 --> 00:01:39.019
GPU 也是 PCIe 总线上有地址的设备。

27
00:01:39.472 --> 00:01:44.444
驱动把显存范围映射成其他设备可以访问的地址窗口。

28
00:01:44.897 --> 00:01:47.911
不过，程序拿到的显存虚拟指针，

29
00:01:48.067 --> 00:01:52.086
并不等于 SSD 直接使用的 DMA 地址。

30
00:01:52.539 --> 00:01:54.418
真正搬运数据的是谁？

31
00:01:54.858 --> 00:01:56.506
在本地直达读取中，

32
00:01:56.624 --> 00:02:00.578
是 SSD 存储控制器里的 DMA 硬件。

33
00:02:01.031 --> 00:02:04.457
它发起带目标地址的 PCIe 写事务，

34
00:02:04.626 --> 00:02:08.529
把数据送到 GPU 端点，再落入对应显存。

35
00:02:08.982 --> 00:02:11.042
保存时方向反过来。

36
00:02:11.495 --> 00:02:15.797
存储控制器向 GPU 映射地址发出读请求，

37
00:02:15.928 --> 00:02:19.225
接收返回的数据，再写入存储介质。

38
00:02:19.678 --> 00:02:22.228
这不是 CPU 逐字节复制，

39
00:02:22.384 --> 00:02:27.279
也不是 GPU 的计算核心运行一个读取 SSD 的程序。

40
00:02:27.732 --> 00:02:34.264
当然，这条路径需要设备、驱动、地址映射和总线拓扑共同支持。

41
00:02:34.716 --> 00:02:38.568
调用了接口，不等于确认发生了直接传输。

42
00:02:39.021 --> 00:02:43.993
条件不足时，有些实现仍可能回退到主机内存中转。

43
00:02:44.446 --> 00:02:46.364
再来看缓存怎么摆放。

44
00:02:46.817 --> 00:02:50.771
服务端先准备一大片存储空间，叫做 slab。

45
00:02:51.211 --> 00:02:53.826
每个缓存对象只占其中一段，

46
00:02:54.008 --> 00:02:57.923
用 offset 和 size 描述起始位置与长度。

47
00:02:58.376 --> 00:03:02.988
对象本身记录位置，并不是装着数据的 CPU tensor。

48
00:03:03.441 --> 00:03:04.702
GPU 这一边，

49
00:03:04.884 --> 00:03:07.988
服务端另有一块 GPU staging buffer，

50
00:03:08.170 --> 00:03:10.707
用来接住正在搬运的一批数据。

51
00:03:11.160 --> 00:03:15.385
它可以反复使用，所以即使 SSD 缓存很大，

52
00:03:15.554 --> 00:03:18.375
也不需要配套分配同样大的显存。

53
00:03:18.827 --> 00:03:22.485
图中的 R0 和 R1，R 表示 region，

54
00:03:22.577 --> 00:03:24.019
也就是注册范围。

55
00:03:24.472 --> 00:03:28.658
它们不是两块 GPU，也不是两个 SSD 分区，

56
00:03:28.802 --> 00:03:31.493
而是同一块显存分配中的两段。

57
00:03:31.933 --> 00:03:34.882
软件按当前实现的十六 MiB 上限，

58
00:03:35.000 --> 00:03:36.042
分段注册。

59
00:03:36.495 --> 00:03:40.823
注册，是让存储库和驱动认识这些显存范围，

60
00:03:40.979 --> 00:03:43.503
准备好直接传输所需的映射。

61
00:03:43.956 --> 00:03:45.836
它不会复制一份缓存。

62
00:03:46.289 --> 00:03:49.921
以后读写时，要找到所属注册区的基址，

63
00:03:50.026 --> 00:03:51.957
再加上区内 offset。

64
00:03:52.410 --> 00:03:54.715
举个例子，八 MiB 的数据，

65
00:03:54.845 --> 00:03:58.027
从第一个注册区的十二 MiB 位置开始放。

66
00:03:58.479 --> 00:04:02.653
前四 MiB 还在这个区，后四 MiB 进入下一个区，

67
00:04:02.796 --> 00:04:04.728
于是拆成两笔读写。

68
00:04:05.180 --> 00:04:07.807
文件 offset 和 buffer offset，

69
00:04:07.912 --> 00:04:09.599
是两套不同的坐标。

70
00:04:10.052 --> 00:04:11.764
还有三个词要分开。

71
00:04:12.204 --> 00:04:15.630
handle，是已经打开或注册的资源引用。

72
00:04:16.082 --> 00:04:19.998
操作系统的 fd，告诉进程打开了哪个文件；

73
00:04:20.168 --> 00:04:21.789
GDS 库的 handle，

74
00:04:21.894 --> 00:04:25.720
则表示这份资源已经接入它的读写机制。

75
00:04:26.173 --> 00:04:28.916
buffer 才是真正放数据的内存。

76
00:04:29.369 --> 00:04:32.021
这里的临时 buffer 在 GPU 上，

77
00:04:32.100 --> 00:04:33.619
不在主机内存里。

78
00:04:34.059 --> 00:04:36.300
另一个叫 Submission 的对象，

79
00:04:36.443 --> 00:04:41.222
只保留原生调用的参数和结果位置，不装整块缓存。

80
00:04:41.675 --> 00:04:45.333
stream，可以理解成一条有顺序的工作队列。

81
00:04:45.786 --> 00:04:49.161
布局转换、存储读写和完成 event，

82
00:04:49.343 --> 00:04:52.756
都能放进同一条队列，约束谁先谁后。

83
00:04:53.196 --> 00:04:57.124
它不是一个应用线程，也不是一根独占的数据线。

84
00:04:57.577 --> 00:04:58.452
使用时，

85
00:04:58.621 --> 00:05:03.104
服务端指定存储路径、缓存容量和 backend 名字，

86
00:05:03.325 --> 00:05:05.952
就能选择这条一级缓存路径。

87
00:05:06.405 --> 00:05:11.570
这时配置的容量指 slab 大小，不是同样大小的主机内存。

88
00:05:12.023 --> 00:05:15.539
部署前仍要准备匹配的驱动和运行库。

89
00:05:16.158 --> 00:05:17.908
cuFile 和 hipFile，

90
00:05:18.065 --> 00:05:22.535
分别接 NVIDIA CUDA 和 AMD ROCm 的运行环境。

91
00:05:22.989 --> 00:05:29.237
除了用户态库，还要核对内核能力、驱动、文件系统和设备拓扑。

92
00:05:29.677 --> 00:05:31.711
安装一个 Python binding，

93
00:05:31.855 --> 00:05:34.031
并不能代替这些前置条件。

94
00:05:34.484 --> 00:05:36.080
再看 uGDS，

95
00:05:36.236 --> 00:05:39.933
它来自香港科技大学广州的 ScaleX Lab，

96
00:05:40.025 --> 00:05:43.722
是开源软件栈，不是一种专用 SSD。

97
00:05:44.162 --> 00:05:47.781
当前公开实现有 CUDA 和 HIP 两条路径，

98
00:05:48.015 --> 00:05:52.317
在这里使用专用原始设备，并需要内核模块配合。

99
00:05:52.770 --> 00:05:55.036
Phoenix 的定位有些不同。

100
00:05:55.489 --> 00:06:00.977
它希望在更底层，把面向多种 xPU 的存储读写统一起来。

101
00:06:01.430 --> 00:06:02.420
应用之下，

102
00:06:02.590 --> 00:06:07.369
由用户态 connector 和内核 P2P backend 适配设备。

103
00:06:07.821 --> 00:06:12.407
但统一是架构方向，不代表所有硬件都已经可用。

104
00:06:12.860 --> 00:06:14.753
自动选择也很克制。

105
00:06:15.205 --> 00:06:19.933
当前两种运行环境，各自选择对应的默认 backend。

106
00:06:20.386 --> 00:06:24.018
它不会先测速，也不会在一个实现失败后，

107
00:06:24.110 --> 00:06:26.170
悄悄切换到 Phoenix。

108
00:06:26.623 --> 00:06:29.237
专用设备 backend 和 Phoenix，

109
00:06:29.303 --> 00:06:30.822
都需要显式选择。

110
00:06:31.275 --> 00:06:32.742
现在进入代码。

111
00:06:33.195 --> 00:06:37.549
工厂先扫描 backend 目录，发现可用的模块名字。

112
00:06:38.002 --> 00:06:40.964
这个步骤不执行每个实现的代码。

113
00:06:41.417 --> 00:06:45.191
通用调度层，也不需要列出所有厂商的名字。

114
00:06:45.644 --> 00:06:50.088
假设配置选择 Phoenix，接下来才导入它的模块，

115
00:06:50.270 --> 00:06:53.155
确认 backend 类继承了公共父类，

116
00:06:53.260 --> 00:06:55.784
再构造对象并检查环境。

117
00:06:56.236 --> 00:07:01.054
发现名字、导入实现、创建对象，是三个不同动作。

118
00:07:01.507 --> 00:07:04.392
然后，上层只说，打开 slab。

119
00:07:04.832 --> 00:07:08.786
文件型父类负责创建文件和预分配容量；

120
00:07:09.059 --> 00:07:12.278
原始设备实现则检查设备和容量。

121
00:07:12.731 --> 00:07:15.474
上层不需要根据 backend 名字，

122
00:07:15.695 --> 00:07:18.438
猜应该创建文件还是打开设备。

123
00:07:18.891 --> 00:07:24.057
真正注册文件资源时，Phoenix 实现才需要加载原生库。

124
00:07:24.510 --> 00:07:27.201
这里加载的是文件接口适配库，

125
00:07:27.345 --> 00:07:30.887
不能只找到 Phoenix 核心库就算完成。

126
00:07:31.340 --> 00:07:36.454
没有选择的可选实现，不应该因为缺库而影响通用代码。

127
00:07:36.906 --> 00:07:41.930
加载以后，还要声明每个原生函数的参数和返回类型。

128
00:07:42.383 --> 00:07:46.763
哪些是指针，哪些是整数，哪些是整数的地址，

129
00:07:46.816 --> 00:07:48.103
都必须精确。

130
00:07:48.543 --> 00:07:53.477
否则，就可能把一个地址截断，或者让底层读错内存。

131
00:07:53.930 --> 00:07:55.577
文件 handle 准备好，

132
00:07:55.747 --> 00:08:00.165
再把 GPU staging buffer 和 stream 交给 backend 注册。

133
00:08:00.618 --> 00:08:05.371
公共层负责调用顺序，具体实现负责底层细节。

134
00:08:05.824 --> 00:08:08.567
有的 stream 注册是真正的操作，

135
00:08:08.724 --> 00:08:12.897
有的只是空操作，但每次读写仍会携带 stream。

136
00:08:13.337 --> 00:08:14.508
多进程之间，

137
00:08:14.664 --> 00:08:18.735
原始 KV Cache 的显存仍归推理 worker 所有。

138
00:08:19.187 --> 00:08:22.291
LMCache server 导入 IPC handle，

139
00:08:22.435 --> 00:08:27.072
建立跨进程映射，而不是通过消息复制整块数据。

140
00:08:27.525 --> 00:08:29.985
只有那块 GPU staging buffer，

141
00:08:30.128 --> 00:08:33.219
是 LMCache 自己分配和管理的。

142
00:08:33.659 --> 00:08:34.714
重点来了。

143
00:08:35.141 --> 00:08:40.822
保存入口收到的是一组缓存键、token 范围和实际 block IDs。

144
00:08:41.275 --> 00:08:43.412
推理引擎的 KV Cache，

145
00:08:43.543 --> 00:08:46.260
按照分页方式放在 GPU 上。

146
00:08:46.700 --> 00:08:51.325
一段逻辑连续的上下文，不保证在物理布局上连续。

147
00:08:51.778 --> 00:08:54.688
因此，首先要等 producer 完成，

148
00:08:54.767 --> 00:08:57.317
不能在引擎还没写完时去读。

149
00:08:57.757 --> 00:09:01.634
存储管理器再为可写的缓存对象预留位置。

150
00:09:02.087 --> 00:09:06.299
对于这条路径，拿到的对象记录的是 slab offset，

151
00:09:06.455 --> 00:09:08.464
而不是 CPU tensor。

152
00:09:08.917 --> 00:09:11.467
进入按对象组传输的方法后，

153
00:09:11.623 --> 00:09:15.320
代码根据对象类型识别出 GDS 对象，

154
00:09:15.425 --> 00:09:16.866
选择对应分支。

155
00:09:17.319 --> 00:09:20.242
这里不会把它当作普通主机缓存，

156
00:09:20.347 --> 00:09:22.923
去获取一个 CPU tensor 地址。

157
00:09:23.376 --> 00:09:26.183
接下来先在 GPU 内部做 gather，

158
00:09:26.288 --> 00:09:27.304
整理布局。

159
00:09:27.757 --> 00:09:31.273
图中四份逻辑数据，分散在不同块里。

160
00:09:31.713 --> 00:09:34.327
搬运 kernel 按照 block IDs，

161
00:09:34.484 --> 00:09:38.077
把它们收集到服务端的 GPU staging buffer，

162
00:09:38.169 --> 00:09:41.041
形成适合存储的一段连续字节。

163
00:09:41.494 --> 00:09:45.281
为什么不让 SSD 直接读取引擎那些页？

164
00:09:45.721 --> 00:09:49.057
因为存储接口处理连续地址和长度，

165
00:09:49.213 --> 00:09:52.124
不理解 token、层和 block IDs。

166
00:09:52.577 --> 00:09:58.838
GPU staging buffer 同时解决布局转换、成批读写和注册生命周期，

167
00:09:58.943 --> 00:10:01.673
把引擎布局与存储接口分开。

168
00:10:02.126 --> 00:10:05.281
注意，这个中转发生在 GPU 上，

169
00:10:05.386 --> 00:10:08.477
并没有把整块缓存绕回主机内存。

170
00:10:08.930 --> 00:10:14.559
用于布局转换和存储读写的不同视图，指向同一块显存分配，

171
00:10:14.664 --> 00:10:18.065
也不会每创建一个视图就再复制一遍。

172
00:10:18.702 --> 00:10:23.081
数据整理好之后，存储上下文根据显存切片，

173
00:10:23.199 --> 00:10:26.071
找到注册基址和区内 offset；

174
00:10:26.126 --> 00:10:28.933
再结合缓存对象的 slab offset，

175
00:10:29.115 --> 00:10:32.155
确定写多少、从哪儿读、写到哪儿。

176
00:10:32.595 --> 00:10:35.660
跨注册区时，就拆成多笔提交。

177
00:10:36.113 --> 00:10:40.054
handle 对象随后调用具体 backend 的异步写入。

178
00:10:40.507 --> 00:10:42.786
前面的 gather 和这里的写入，

179
00:10:42.930 --> 00:10:45.132
在传输 stream 上有顺序，

180
00:10:45.224 --> 00:10:50.840
所以存储设备不会抢先读取还没整理好的 GPU staging buffer。

181
00:10:51.293 --> 00:10:52.683
写入完成之后，

182
00:10:52.788 --> 00:10:56.021
event 和 callback 衔接收尾流程，

183
00:10:56.164 --> 00:10:59.255
存储管理器完成写入状态的更新。

184
00:10:59.708 --> 00:11:02.554
这时，缓存对象才完成发布，

185
00:11:02.737 --> 00:11:05.222
相关 buffer 才能按约定复用。

186
00:11:05.675 --> 00:11:09.887
函数已经返回，与设备已经写完，是两回事。

187
00:11:10.340 --> 00:11:13.109
取回时，先找到命中的缓存，

188
00:11:13.213 --> 00:11:16.343
以及这一次请求的目标 block IDs。

189
00:11:16.796 --> 00:11:22.361
目标块可能和上一次完全不同，所以不能把保存时的物理地址，

190
00:11:22.466 --> 00:11:24.333
直接拿来当恢复位置。

191
00:11:24.786 --> 00:11:30.209
存储管理器交出预取结果，并在读取期间保留这些对象，

192
00:11:30.378 --> 00:11:34.771
避免字节还没搬完，缓存位置就被淘汰或复用。

193
00:11:35.224 --> 00:11:38.676
stream 也会建立与 producer 的依赖关系。

194
00:11:39.128 --> 00:11:41.962
然后，handle 提交异步读取，

195
00:11:42.079 --> 00:11:43.972
把 slab 中的连续字节，

196
00:11:44.115 --> 00:11:47.129
送进已经注册的 GPU staging buffer。

197
00:11:47.582 --> 00:11:51.240
SSD 只需要认识地址、偏移和长度，

198
00:11:51.461 --> 00:11:54.900
不需要知道这些字节属于哪一层注意力。

199
00:11:55.353 --> 00:11:57.426
等读取在 stream 上完成，

200
00:11:57.582 --> 00:12:00.029
布局搬运 kernel 再做 scatter，

201
00:12:00.211 --> 00:12:02.825
把 GPU staging buffer 里的数据，

202
00:12:02.917 --> 00:12:05.132
分散写入这一次的目标块。

203
00:12:05.572 --> 00:12:09.694
图中逻辑顺序没有改变，但实际 block IDs，

204
00:12:09.760 --> 00:12:11.420
已经换成了新的位置。

205
00:12:11.873 --> 00:12:15.956
这就是读取同样需要 GPU staging buffer 的原因。

206
00:12:16.396 --> 00:12:21.704
连续存储字节与引擎分页布局之间，需要一次明确的转换。

207
00:12:22.157 --> 00:12:26.085
搬运还要遵守对象分组和需要跳过的范围，

208
00:12:26.268 --> 00:12:28.366
避免覆盖应保留的 token。

209
00:12:28.819 --> 00:12:32.090
最后，完成 event 告诉后续工作，

210
00:12:32.247 --> 00:12:37.387
目标缓存已经准备好；读取收尾流程再释放对象保护。

211
00:12:37.827 --> 00:12:42.812
不能刚把读命令发出去，就让模型使用尚未到达的数据，

212
00:12:42.956 --> 00:12:45.776
也不能提前让存储区域被覆盖。

213
00:12:46.229 --> 00:12:48.044
再把异步单独拎出来。

214
00:12:48.484 --> 00:12:54.359
上层调用返回，只表示请求已经提交，不表示数据已经搬完。

215
00:12:54.811 --> 00:12:59.526
CPU 可以继续安排工作，而 GPU 和存储设备，

216
00:12:59.670 --> 00:13:02.245
沿着依赖关系完成后续任务。

217
00:13:02.698 --> 00:13:06.047
保存时，顺序是先 gather，再写盘，

218
00:13:06.177 --> 00:13:08.005
再记录完成 event。

219
00:13:08.458 --> 00:13:11.485
取回时，是先读盘，再 scatter，

220
00:13:11.577 --> 00:13:12.786
再记录 event。

221
00:13:13.239 --> 00:13:18.469
有序不等于并行，async 也不是自动让所有步骤同时发生。

222
00:13:18.922 --> 00:13:21.395
还有一个容易忽略的生命周期：

223
00:13:21.603 --> 00:13:25.248
底层异步函数可能继续使用参数的地址。

224
00:13:25.700 --> 00:13:30.699
Submission 要让这些长度、偏移和结果变量一直活着。

225
00:13:31.152 --> 00:13:35.931
否则，数据还没搬完，参数内存却已经被回收了。

226
00:13:36.371 --> 00:13:40.673
当前实现用 checkpoint 回收已经完成的 Submission，

227
00:13:40.920 --> 00:13:44.139
但这不等于逐笔核验实际传输字节数。

228
00:13:44.592 --> 00:13:48.495
执行完成、读写成功、数据已经持久化，

229
00:13:48.600 --> 00:13:53.070
是不同层次的问题，不能只凭一个 event 就混为一谈。

230
00:13:53.523 --> 00:13:55.054
最后来看扩展。

231
00:13:55.507 --> 00:13:57.915
以现有的 Phoenix 实现为例，

232
00:13:58.084 --> 00:14:03.650
假设今天重新接入它，核心不是往通用调度里再加一个判断，

233
00:14:03.742 --> 00:14:07.490
而是在 backend 目录里，新增一个实现模块。

234
00:14:07.943 --> 00:14:10.737
它的 backend 类继承文件型父类，

235
00:14:10.932 --> 00:14:13.160
复用存储文件的准备流程；

236
00:14:13.368 --> 00:14:16.292
它的异步 handle 继承公共 handle，

237
00:14:16.396 --> 00:14:17.954
承接具体读写。

238
00:14:18.407 --> 00:14:22.670
共有的驱动状态和资源释放，可以放在父类中，

239
00:14:22.801 --> 00:14:24.938
让需要的实现直接使用。

240
00:14:25.391 --> 00:14:27.606
接口可以按三组来理解。

241
00:14:28.059 --> 00:14:31.163
第一组检查环境，准备存储和驱动；

242
00:14:31.396 --> 00:14:33.869
第二组登记 buffer 与 stream；

243
00:14:34.064 --> 00:14:36.627
第三组负责异步读写和释放。

244
00:14:37.079 --> 00:14:41.047
公共层调用这些能力，而不是猜 backend 名字。

245
00:14:41.499 --> 00:14:45.312
Phoenix 自己的差异，留在自己的模块里处理：

246
00:14:45.507 --> 00:14:49.513
首次使用时加载适配库，检查异步符号，

247
00:14:49.618 --> 00:14:53.637
绑定函数签名，解释错误码和偏移参数。

248
00:14:54.090 --> 00:14:58.057
新增 backend，不要求修改所有上层调用者。

249
00:14:58.510 --> 00:15:01.317
生命周期也不必强行整齐。

250
00:15:01.770 --> 00:15:05.377
当前 Phoenix 封装走隐式驱动初始化，

251
00:15:05.584 --> 00:15:09.887
stream 注册不接收标志位，并允许是空操作。

252
00:15:10.340 --> 00:15:14.642
它不需要照搬其他库的数字常量，但每次异步读写，

253
00:15:14.734 --> 00:15:16.188
仍要传入 stream。

254
00:15:16.830 --> 00:15:19.482
对照最初接入 Phoenix 的改动，

255
00:15:19.690 --> 00:15:23.838
当时需要修改两个中央文件，登记配置与调度。

256
00:15:24.292 --> 00:15:29.767
现在，在已有设备平台的前提下，新模块可以通过目录发现，

257
00:15:29.872 --> 00:15:31.572
不再要求改这两处。

258
00:15:32.012 --> 00:15:35.850
收益是减少联动，而不是消灭实现代码。

259
00:15:36.303 --> 00:15:41.520
原生接口适配、针对性测试、依赖说明和硬件验证，

260
00:15:41.651 --> 00:15:42.809
仍然都需要。

261
00:15:43.249 --> 00:15:48.904
尤其是底层没有支持的新设备，不能靠加一个模块就宣称可用。

262
00:15:49.357 --> 00:15:53.285
软件可扩展，与硬件已验证，要分开说。

263
00:15:53.725 --> 00:15:58.479
所以，GDS 的价值，不是把 SSD 变成显存，

264
00:15:58.609 --> 00:16:02.383
而是用更大的容量保留更多可复用缓存，

265
00:16:02.488 --> 00:16:05.476
再用合适的路径把它们送回计算。

266
00:16:05.929 --> 00:16:07.358
最终是否划算，

267
00:16:07.501 --> 00:16:12.306
还要看命中率、带宽、访问粒度和重新计算的成本。

268
00:16:12.759 --> 00:16:17.036
Phoenix 尝试在设备读写层统一多种加速器，

269
00:16:17.205 --> 00:16:22.061
而缓存框架在更上层，统一缓存对象和传输流程。

270
00:16:22.514 --> 00:16:24.355
两者各自守住边界，

271
00:16:24.550 --> 00:16:29.084
才有机会让不同设备共享同一套清晰的缓存逻辑。

272
00:16:29.537 --> 00:16:33.685
回头看，神秘感其实来自几个概念叠在一起。

273
00:16:34.138 --> 00:16:38.002
把数据路径、资源归属和完成顺序分开，

274
00:16:38.249 --> 00:16:41.610
再用继承和多态把 backend 差异收好，

275
00:16:41.715 --> 00:16:45.283
这条从 SSD 到 GPU 的缓存通路，

276
00:16:45.375 --> 00:16:47.925
就变得可以理解，也可以扩展。
