近数据计算：存算融合

可视化演示

展示冯诺依曼架构数据搬运瓶颈与存算融合方案对比，包括近存计算和存内计算两条路线及能效带宽提升分析。切换模式查看不同维度，拖动滑块调节数据规模。

数据搬运瓶颈

老张发现问题的根源在于“取食材太远”。他从厨房窗口望出去，街对面的食材仓库灯火通明——那是他的全部家当。可每天营业额的很大一部分，都耗在了来来回回的搬运上。他算过一笔账：做一道菜真正下锅不超过三分钟，但取一次食材至少十分钟，客人等得着急，他也累得够呛。

在计算机领域，这种“搬运之痛”被称为冯诺依曼瓶颈。1945年冯诺依曼提出了经典计算机架构：计算单元（CPU）和存储单元（内存）物理分离，程序和数据都放在内存里，CPU要算数必须先把数据从内存“请过来”。七十多年过去，CPU的计算速度暴增了数百万倍，但数据搬运的速度只提升了几十倍，“搬运”与“加工”的差距越来越大，成了名副其实的“内存墙”。

让我们把这个瓶颈量化地写出来：

$$\displaystyle T_{\text{总}} = T_{\text{算}} + T_{\text{搬}}, \qquad T_{\text{搬}} = \frac{D}{v} + \frac{B}{w}$$

1. T总：完成一次计算任务消耗的总时间，包含加工时间和取料时间两部分。

$$T_{\text{总}} = T_{\text{算}} + T_{\text{搬}}$$

2. T算：CPU真正做运算的时间，这部分往往很短，就像老张颠勺只要几秒。

$$T_{\text{算}} = \text{CPU 实际运算时间}$$

3. T搬：数据在内存与CPU之间的搬运时间，AI任务中往往占大头。

$$T_{\text{搬}} = \frac{D}{v} + \frac{B}{w}$$

4. D/v：搬运距离除以传输速度，物理距离越长延迟越高，这是“路远”的代价。

$$\frac{D}{v} = \text{距离延迟}$$

5. B/w：数据量除以通道带宽，数据量越大排队越久，这是“货多”的代价。

$$\frac{B}{w} = \text{带宽排队延迟}$$

一个直观的例子：现代处理器执行一次加法约0.3纳秒，而从内存取一次数据要约100纳秒——时间比超过300倍。老张说得没错：“我等食材的时间，够我再炒三桌菜了。”所以，要想让计算机真正快起来，光加快“颠勺”没用，得先解决“取食材”的问题。

近存计算

老张的第一次改造，是在仓库门口支了一张巨大的配菜台。他把常用的鸡肉、花生、大葱提前处理好摆在台上，取料距离从“横跨街道”缩短到“出门就是”。菜做出来的时间肉眼可见地变快，客人终于愿意给好评了。

这就是“近存计算”（Near-Memory Computing）的思路：计算单元不搬走，而是让存储设备“靠近”计算单元。具体怎么靠近？靠先进封装技术。最典型的是HBM（高带宽内存）：用硅通孔（TSV）技术把多层存储芯片像千层饼一样垂直堆叠，再与AI加速芯片封装在同一个基板上，两者之间用宽而短的线路相连，数据搬运的“路”更短也更宽了。

近存计算带来的延迟改善率可以这样计算：

$$\displaystyle \eta = \frac{T_{\text{旧}} - T_{\text{新}}}{T_{\text{旧}}} \times 100\%$$

1. T旧：改造前传统架构的数据搬运时间，对应老张跑街对面取食材的耗时。

$$T_{\text{旧}} = T_{\text{传统搬运}}$$

2. T新：采用近存计算后（计算单元离存储很近）的搬运时间。

$$T_{\text{新}} = T_{\text{近存搬运}}$$

3. η：搬运时间的改善率，分子是“省下的时间”，分母是“原来花的时间”，乘100%得到百分比。

$$\eta = \frac{\text{节省时间}}{\text{原时间}} \times 100\%$$

以HBM为例，与传统DDR内存相比，位宽从64位提升到1024位，等效带宽提升10倍以上，AI芯片的算力利用率因此从不足30%拉到60%以上。老张的配菜台，真不是白摆的——同样的老张，同样的锅，上菜速度却翻了几番。

存内计算

老张是个敢想的人。配菜台还不够，他索性在仓库里装了切菜机、绞肉机、自动调味机——食材从入库到初加工全在仓库内完成，连仓库门都不用出。这下取食材的时间变成了零。

这就是“存内计算”（In-Memory Computing，简称PIM）。它不再满足于“缩短搬运距离”，而是直接在存储单元内部完成计算。怎么做到？以AI最常用的“乘加运算”为例：把神经网络权重映射为存储器件的物理参数（如ReRAM器件的电导值），输入信号以电压形式送入存储阵列，根据基尔霍夫电流定律，输出端自动汇出加权求和的结果。

$$\displaystyle y = \sum_{i=1}^{n} w_i x_i = w_1 x_1 + w_2 x_2 + \cdots + w_n x_n$$

1. y：输出结果，对应神经网络中一个神经元的输出值。

$$y = \text{神经元的输出}$$

2. x_i：第 i 个输入信号，以电压形式输入存储阵列。

$$x_i = \text{第 } i \text{ 个输入电压}$$

3. w_i：第 i 个权重，预先映射为存储单元的电导值。

$$w_i = \text{第 } i \text{ 个权重（电导）}$$

4. Σ 求和：由电流在阵列中的自然汇合并行完成，不需要把每个乘积搬回CPU。

$$\sum_{i=1}^{n} w_i x_i = \text{阵列内并行乘加}$$

更关键的是，这 n 次乘加是“同时发生的”——模拟电路天然支持并行。如果把数据搬到CPU逐个计算，时间复杂度是O(n)；而存内计算的等效时间复杂度接近O(1)。当然，模拟计算精度有限，追求高精度时也可以用数字存内计算（在存储单元旁集成数字运算逻辑）。老张的仓库加工车间，一次就能处理一整筐食材，但交付的“半成品”也需要质检员把把关。

融合架构

老张没有满足于单一改造。他重新设计了整个后厨：仓库内部装初加工流水线（存内计算），仓库门口保留精细配菜台（近存计算），还雇了一位“传菜调度员”（数据调度）——常见的食材在仓库内直接处理，复杂的菜式在门口精细加工，两边互不耽误。

这就是“融合架构”。在真实芯片中，它表现为两级协同：第一级是存内计算宏单元，专门处理规则的大规模矩阵运算；第二级是贴近存储的近存计算岛，处理不规则的数据访问和灵活控制流。两级之间由高性能片上网络连接，由编译器与运行时共同调度，这就是软硬件协同设计的含义。

$$\displaystyle \bar{d} = \alpha \times d_{\text{近}} + (1-\alpha) \times d_{\text{内}}$$

1. d̄：整个系统平均数据搬运距离，衡量“数据到底跑了多远”。

$$\bar{d} = \text{平均搬运距离}$$

2. α：数据访问中走“近存路”的比例，取值在0到1之间。

$$\alpha = \text{近存访问比例}$$

3. d近：近存计算单元到存储单元的物理距离。

$$d_{\text{近}} = \text{近存层距离}$$

4. d内：存内计算的距离，非常接近0。

$$d_{\text{内}} \approx 0$$

当调度器把高频、规则的数据访问导向存内层，α的值趋向于0——大多数数据走“零搬运”路线，平均搬运距离就被压到极致。老张的后厨，做到了“能不出仓库就不出仓库”。

AI加速收益

老张的餐厅迎来一笔大单：承办婚宴的“满汉全席”，一百多道菜，需要几千斤食材。AI大模型就是这样一位“大胃王食客”，一个万亿参数模型训练时，需要搬运的数据以PB（百万GB）计——如果还是老后厨，光取食材就能把老张累趴下。

存算融合对AI的加速是结构性的。以Transformer模型为例，每一层的矩阵乘法都要把权重和激活值反复从内存取出。用存算融合芯片，这些乘加直接在存储阵列中完成，避免了海量数据的往返跳跃。行业报告常见的数字是：在相同功耗下，能效提升10~100倍；推理场景中，带宽利用率从30%拉到90%以上。

$$\displaystyle \text{能效提升倍数} = \frac{E_{\text{传统}}}{E_{\text{融合}}} \approx 10 \sim 100$$

1. E传统：传统冯诺依曼架构完成某AI任务消耗的总能量。

$$E_{\text{传统}} = \text{传统架构总能耗}$$

2. E融合：存算融合架构完成同一任务消耗的总能量。

$$E_{\text{融合}} = \text{融合架构总能耗}$$

3. 比值：代表能效提升的倍数，10~100是学术论文与产业报告中常见的区间。

$$\text{能效提升倍数} = \frac{\text{老能耗}}{\text{新能耗}} = 10 \sim 100$$

这几十倍的差距，对AI从业者意味着“省钱”还是“破产”的区别：同样的算力采购预算，存算融合方案可以支撑几十倍大的模型。老张的厨艺没变，变的是“备料”的效率——这就是为什么存算融合被称为AI算力的“倍增器”。

性能对比

老张把三种方案列了一张对比表，贴在厨房墙上：

| 方案 | 相对能耗 | 相对延迟 | 改造成本 | 适用场景 |

|---|---|---|---|---|

| 传统架构 | 1 | 1 | 0 | 通用计算 |

| 近存计算 | 约0.2 | 约0.3 | 中 | AI推理、通用加速 |

| 存内计算 | 约0.05 | 约0.1 | 高 | 固定模式AI运算 |

这张表背后的衡量指标是“能效比”：

$$\displaystyle E_{\text{eff}} = \frac{N}{E_{\text{总}}}$$

1. N：单位时间完成的操作数，如每秒万亿次运算（TOPS）。

$$N = \text{完成的操作数}$$

2. E总：完成这些操作消耗的总能量，包含计算能耗和搬运能耗。

$$E_{\text{总}} = E_{\text{算}} + E_{\text{搬}}$$

3. Eeff：能效比，即每瓦能耗能完成的运算量，单位是TOPS/W。

$$E_{\text{eff}} = \frac{\text{操作数}}{\text{总能耗}}$$

表格中的数字是量级示意。真实系统中，近存计算和存内计算各有取舍：近存计算改造灵活、兼容性好；存内计算能效最优，但存储容量和灵活性受限。老张的结论很务实：“没有最好的后厨，只有最合适的菜系。”做快餐（大模型推理）选存内，做私房菜（复杂逻辑）选近存，想两头兼顾就上融合架构。

技术挑战

老张的仓库加工车间投入运营后，麻烦事也不少。首先是“精度损失”：模拟存内计算本质是用模拟信号做运算，受噪声、温度、工艺漂移影响，结果天然不如数字计算精确——就像仓库里的绞肉机，再好也切不出大厨的细丝。要做高精度推理，需要额外加校正电路或改用数字存内计算，代价是面积和功耗上升。

其次是“编程模型”：程序员习惯了“内存是一块地、CPU是处理器”的模型。存算融合让内存也能“算”——现有的编译器、指令集、内核调度全都需要重写。老张的“新厨具”没有配套“新菜谱”，大厨们无从下手。再有“工艺兼容”：存内计算的存储器件（如ReRAM、MRAM）和成熟CMOS逻辑工艺的集成还不成熟，良率和可靠性是量产之痛。

$$\displaystyle \text{SNR} = \frac{P_{\text{信号}}}{P_{\text{噪声}}}$$

1. P信号：模拟计算中有用的信号功率，代表“真实的味道”。

$$P_{\text{信号}} = \text{信号功率}$$

2. P噪声：电路中的噪声功率，如热噪声、电磁干扰等。

$$P_{\text{噪声}} = \text{噪声功率}$$

3. SNR：信噪比，比值越低，运算结果误差越大。

$$\text{SNR} = \frac{\text{信号}}{\text{噪声}}, \text{SNR 低则精度差}$$

老张的感悟是：新设备不是装上去就完事，得配新流程、新培训、甚至新装修。存算融合从论文走向量产，还需要翻越精度、软件、工艺、生态这几座大山——这恰恰是AI工程师和芯片工程师共同的机会。

未来方向

老张的“智能后厨”还在进化。他听朋友说，未来的厨房会有“可重构灶台”——同一台设备今天做川菜，明天做粤菜，刀工火力全自动适配。芯片界这叫“可重构存算”，根据不同的AI模型动态调整存算一体单元的配置：今天跑Transformer，明天跑卷积网络，同一颗芯片，不同算力分配，让“设备适应算法”而不是“算法迁就设备”。

另一个方向是“光存算融合”。电信号传输有阻力和发热，光信号的传播速度更快、带宽更大、能耗更低——如果把芯片间的电信号换成光信号，数据搬运的瓶颈能被进一步击穿。产业落地也已经在路上：多家国际大厂发布了存算一体原型芯片，国内初创公司推出了面向大模型推理的存算一体加速卡，云厂商开始测试存算融合服务器。有研究机构预测，到2027年全球存算一体市场规模将超过30亿美元。

老张的后厨，正在为“满汉全席”的下一个大单装修升级。而你我这些“食客”，很快就能尝到这道名为“存算融合”的新菜——它上菜更快，能耗更省，而且正以肉眼可见的速度，从实验室的“试菜间”端向产业的大餐桌。

AI 应用场景

Python 演示

import math def movement_cost(m, n, k, distance):    """估算一次矩阵乘法 A(mxk) x B(kxn) 的搬运成本"""    reads = m * k + k * n    writes = m * n    return (reads + writes) * distance def run():    m = n = k = 1024    baseline = movement_cost(m, n, k, 100)    print("=== 1024x1024 矩阵乘法数据搬运成本对比 ===")    for name, dist in [("传统冯诺依曼", 100), ("近存计算", 10), ("存内计算", 1)]:        cost = movement_cost(m, n, k, dist)        speedup = baseline / cost        print(f"{name}: 成本={cost:14.2e} 相比传统={speedup:5.1f}倍") if __name__ == "__main__":    run()

1. reads = m * k + k * n读取矩阵A和B的全部元素次数，数据量由矩阵维度决定
2. writes = m * n写回结果矩阵C的元素次数
3. return (reads + writes) * distance总搬运成本与搬运距离成正比，距离是唯一可优化的杠杆
4. baseline = movement_cost(m, n, k, 100)以传统架构距离100为基准（相当于老张跑去街对面取菜）
5. cost = movement_cost(m, n, k, dist)计算某架构下的搬运成本，距离越省成本越低
6. speedup = baseline / cost相对传统架构的提升倍数，距离缩短10倍则提升10倍

常见误区

面试题