从指令流到数据流：SambaNova 可重构架构与计算图映射

可视化演示

展示SambaNova四大核心：RDU可重构PE阵列架构、计算图到硬件映射、数据驱动流水线执行、分布式SRAM存储管理。

架构演进：从指令到数据流

每条单向桥梁，但车一到桥口就得看红绿灯——指令决定接下来谁走谁停。传统 CPU/GPU 的每条计算都伴随取指、译码、读寄存器、执行、写回五个步骤，其中前两步纯粹是在“看红绿灯”，没有真正运送货物。当深度学习的矩阵规模越来越大，这种“停车确认”的开销占比越来越高，就像城市里车全堵在路口等灯。

RDU 的思路是把红绿灯拆了，改成全互通立交：编译好的数据通路一旦接通，数据从一端流入，沿途每个计算单元自动执行，不再需要逐条指令指挥。芯片上有一组可重构的交换网络（Switch Network），它像一个按图纸自动拼装的立交桥，数据流到哪、在哪计算，都由预先配置好的通路决定。硬件层面，RDU 的架构被设计成四层：地址存储层（Addressable Memory，像立体车库）、Pattern 存储层（Pattern Memory，存路况规则）、Pattern 计算层（Pattern Compute Unit，PCU，沿路服务区）以及阵列配置与向量单元层（Array Configuration and Vector Unit，掌管全局节拍）。

这套“路网”相对传统指令流的核心收益，是省掉了指令获取与译码的能量与时间。假设每完成一次乘加需要 $n$ 个周期的指令开销，而数据流执行只需 1 个周期的直通计算，则加速比可以写成：

一辆车从城东到城西，老路要过 20 个红绿灯，新立交一路绿灯直达——这就是数据流架构对指令流架构的降维打击。理解了这一点，后面所有内容都建立在这个直觉上：把控制逻辑从“每步都要”变成“一次建好，全程直通”。

计算图映射：图纸如何画

接下来是本文的主角：既然 RDU 是一张可以按需重连的“路网”，那么 AI 编译器具体怎么把计算图画成这张路网？答案是三步走：拆 Pattern、选位置、定路由。深度学习模型在编译器里是一张计算图，每个节点是一个算子（如矩阵乘、卷积、激活函数）。编译器首先把这些算子拆解成 RDU 硬件能直接执行的“数据流 Pattern”——类似把一段复杂车流拆成几类标准车型：矩阵乘可以映射为一个分布式累加树，卷积可以映射为一个环形邻近交换矩阵。

拆好 Pattern 后是位置选择（Placement）：每个 Pattern 该放在哪一排 PCU 上？SambaNova 的编译器会做分区与团分析，把计算图中的强连通区域聚在一起，尽量让通信距离最短。这一步类似城市规划中把“总是互相送货”的工厂放在同一个工业园。随后是路由编排（Routing）：芯片上的交换网络像一条条可编程滑轨，编译器决定数据从哪个 Pattern 的哪一行流出，经过哪条轨，进入下一个 Pattern 的哪一列。这一步直接决定了数据搬运的带宽是否够用。

最后是调度（Scheduling），它解决“什么时候流”的问题。数据流架构看似没有指令，但其实有一个全局节拍器——阵列配置与向量单元层会按编译好的时间表，给各 PCU 发送“开始/结束”信号。数据流的调度与传统指令调度最大的区别是：它不需要等指令译码，只需要等上游数据到达。于是，执行一个计算图的总时间可以写成：

值得注意的是，映射阶段不是一次性的：SambaNova 区分了“离线映射”与“在线调度”。对于大模型这种静态结构，离线映射可以提前数小时完成，运行时直接加载路网配置；对于动态图（如循环、条件分支），则必须在线调度，边跑边“修路”。这就像城市的主干道可以提前规划，但临时封路或事故绕行只能在车流中实时调整。对编译器工程师而言，如何平衡离线预铺路与在线动态改路，是决定推理延迟的关键。

DataScale：训练推理全栈

有了“一张图”的芯片，还得有“一座城”的系统。SambaNova 的 DataScale 系统本质上是一座由 16 个节点（每个节点含 8 颗 RDU）组成的 AI 算力城市，节点间通过可配置的高速交换网络互联，形成一个统一的计算池与内存池。对编译器而言，这意味着计算图不仅能映射到一颗芯片，还能跨芯片、跨节点映射——编译器把整张计算图按层或按张量切分，分发给不同 RDU。

DataScale 最让我这个编译器研究者兴奋的设计，是它在训练与推理之间保持状态一致性：训练时 SambaFlow 生成的执行图，推理时可以直接复用同一套图与同一套映射结果，不需要像传统方案那样“训练一套图、导出、再转成推理引擎的图”。少一次格式转换，就少一层信息丢失，也少一层部署风险。它背后的机制是 DataScale 的内存引擎（Memory Engine）统一管理主机内存与 RDU 内存，训练和推理访问的是同一个“内存城市”，数据不再需要跨城搬运。

对于大模型扩展，DataScale 提供的是多维并行支持：数据并行把同一个模型复制到多个节点、各喂各的数据；模型并行把网络不同层放到不同节点、按序流水执行；张量并行则把一层内的矩阵切成多块分到不同 RDU 上计算后再聚合。编译器要做的，就是在这三种并行模式间做组合优化，并在图中插入“跨节点聚合通信”节点。整个系统的有效算力可以简洁地表达为：

如果把 RDU 比作一条条智能高速，DataScale 就是把这些高速织成的“城市快速路网”：训练是白天的高峰流量测试，推理是夜间的常态化运营，而编译器则是总设计师，负责让白天和夜间用同一套路网系统，避免白天修路、晚上另建一套的浪费。对需要部署百亿参数大模型的公司来说，这套“一图到底”的设计能显著降低从训练到推理的工程成本。

稀疏性与动态图优化

现在进入本文最有“编译器味”的部分：稀疏性与动态图。公路上的车流永远不是满载的——很多车是空车，很多道是空道。深度学习同样如此：Transformer 的注意力矩阵大量接近零，推荐系统的 Embedding 表极度稀疏，激活函数（如 ReLU）让一半的神经元输出归零。传统 GPU 遇到这些零依然照算不误，好比空车也占一条车道。

RDU 的数据流架构天生适合处理稀疏：稀疏性就是动态的路况信息。编译器可以在离线阶段做静态稀疏分析，识别出哪些权重长期为零，直接不为它们铺设数据通路；运行时，PCU 还能检测到流入的数据是否为 0，如果为 0 就跳过计算，直接把结果透传到下一级。这被称为“零值跳过（zero-value skip）”，是 RDU 的一大杀手锏。在编译器层面，这意味着生成的映射不仅要描述“数据从哪算到哪”，还要描述“哪些地方可以绕过”。

动态图优化更进一步：计算图中存在条件分支、循环、动态维度形状，传统编译器只能按最坏情况铺路（好比把所有岔路都修成四车道）。SambaNova 的编译器面对动态算子，会生成多套可切换的 Pattern 配置，运行时依据张量形状与分支条件选择切换路径，每次切换只需微秒级延迟。以稀疏加速为例，设稠密计算的耗时 $T_{\text{dense}}$，被跳过的零值比例（稀疏度）为 $\rho$，则有效耗时可估计为：

这种“静态剪枝 + 动态跳过”的组合，让编译器第一次真正参与了模型的性能优化：传统 GPU 上，模型稀疏意味着要写稀疏矩阵算法库；在 RDU 上，稀疏只是编译器映射时的一张“绕行图”。这也解释了为什么 SambaNova 官方宣称在稀疏化模型上相比 GPU 有数十倍效率提升——不是因为 RDU 算得更快，而是因为它不算不需要算的东西。

编译与运行时栈

讲了这么多“图纸”，现在终于到了画图的人：SambaNova 的编译与运行时软件栈。整套栈可以看作一个把高级模型语言翻译成芯片路网配置的“翻译局”，从上到下分四层：最顶层是前端，接收 PyTorch、ONNX 等格式的模型，做算子规范化、常量折叠、图优化等处理，输出一张中间表示计算图；第二层是 SambaFlow 映射器，它是最核心的一层，负责把中间图拆成 Pattern、选位置、定路由、建立 PCU 阵列的时空编排；第三层是在线调度器，处理动态形状、条件分支、循环等无法在编译期确定的结构，在运行时动态切换 Pattern；最底层是RDU 运行时，管理芯片上的状态同步、内存分配与数据搬运。

这套分层结构的关键设计哲学是“离线与在线分工”：能静态做的优化绝不拖到运行时。SambaFlow 在编译期完成 95% 以上的映射工作，生成一组“Pattern 配置 + 路由表 + 调度表”的二进制包；运行时只需要把配置加载到芯片的 Pattern Memory 与交换网络寄存器中，并按调度表触发执行。动态图的部分则被编译成“配置库”，在线调度器根据实际数据流选择加载哪一套配置。

对于存储管理，RDU 采用两级存储：芯片上的Scratchpad 内存（可寻址存储）承担高频数据暂存，DRAM 承担大容量权重存储；编译器通过“内存规划”决定哪些权重常驻片上、哪些按需换入换出。这类似城市物流中心：高频商品放楼内仓库，低频大件放城郊仓库，由调度系统决定何时调拨。由于编译器全盘掌握计算图，它能做到极精准的预取——数据需要时才刚到位，避免浪费带宽。

与 GPU 架构的对比

把 RDU 和 GPU 放在一起，就等于把“智能高速公路网”和“超大规模红绿灯路口群”放在一起比较。GPU 的成功逻辑是：反正我红绿灯多（数千个计算核心）、车道宽（SIMD 宽向量），哪怕每辆车都停一下，总吞吐也能靠并行堆上去。RDU 的逻辑则是：我把路网直接搭好，车流不停。两者的哲学差异在编译器上体现得淋漓尽致——GPU 的编译器（如 NVCC）主要做指令级调度与寄存器分配，目标是让每个线程的指令流尽量不阻塞；RDU 的编译器则做空间映射，目标是让数据流在硬件上“一路绿灯”。

从系统层面看，GPU 必须依赖 CPU 主机来管理指令流：每个 kernel 启动都要 CPU 下发指令、GPU 取指执行，每层计算之间有同步开销。RDU 一旦配置完成，芯片内部的 PCU 阵列就是一台“自治的数据流计算机”，主机只在图切换时介入。这也是为什么在同等工艺下，RDU 的能效比往往更优——它省掉的不仅是指令开销，还有 CPU-GPU 之间的控制流同步。

当然，没有免费的午餐。RDU 的可编程性远不如 GPU：GPU 是通用指令集，什么算法都能跑；RDU 的路网是为静态数据流优化的，遇到极端动态、逻辑分支繁多的模型，编译器会陷入“频繁改路”的困境。因此 RDU 的最佳舞台是结构规整的 Transformer 系模型与稀疏化模型，而非常规的通用计算。对 AI 编译器开发者来说，两者的选择本质上是在做“可编程性 vs 极致能效”的权衡——而 SambaNova 的选择很明确：用编译器的智能换取硬件的极致效率。

工程实践与未来趋势

最后，把镜头拉回真实的工程现场。要在 DataScale 上部署一个 1750 亿参数的大模型，编译器实际要做这么几件事：先把模型按层切分成若干“切片图”，每个切片图分配到不同节点；对每个切片做 Pattern 分解与路由编排；在切片边界插入重分配通信节点，把张量从上一个 RDU 的输出搬运到下一个 RDU 的输入；最后生成整张图的全局调度表。这套流程与传统的“算子融合 + 图切分”相辅相成，但对空间映射的要求更高——你不仅要告诉硬件“算什么”，还要告诉它“在哪算、往哪搬”。

另一个典型实践是稀疏推荐系统：推荐模型里动辄上亿维的 Embedding 表，绝大多数条目从未被访问。传统 GPU 方案把整张表驻留显存，浪费带宽；RDU 方案让编译器把 Embedding 表按访问频率分片，高频片上驻留、低频动态换入，再配合零值跳过，让推理吞吐大幅提升。SambaNova 官方公布的推荐模型性能数据中，相比 A100 的吞吐提升可达数倍到数十倍，主要就来自这套“编译器驱动稀疏”的打法。

展望未来，可重构数据流架构的编译方向有两条主线：一是编译期自动搜索，用图优化与强化学习自动发现最优映射策略，替代人工调参；二是面向数据流的算子原语库建设，把卷积、注意力、范数等高频算子沉淀为高度优化的 Pattern 模板，让上层开发者写出接近硬件极限的代码。对从业者而言，理解“计算图- Pattern-拓扑-路由”这条链条，就能在任何一家做可重构芯片或数据流架构的公司里快速上手，也能在 GPU 生态中识别出哪些优化是“治标”，哪些是“治本”。

---

AI 应用场景

Python 演示

import numpy as npfrom collections import deque  class Op(object):    """一个简单计算图算子。"""    def __init__(self, name, kind, weight=None):        self.name = name        self.kind = kind  # 'matmul' | 'relu' | 'add' | 'output'        self.weight = weight  # 二维矩阵或 None        self.ins = []        self.outs = []  class Graph(object):    """极简计算图。"""    def __init__(self):        self.ops = []     def add_op(self, op):        self.ops.append(op)        return op     def add_edge(self, src, dst):        src.outs.append(dst)        dst.ins.append(src)     def topo_order(self):        indeg = {id(op): len(op.ins) for op in self.ops}        q = deque([op for op in self.ops if indeg[id(op)] == 0])        order = []        while q:            cur = q.popleft()            order.append(cur)            for nxt in cur.outs:                indeg[id(nxt)] -= 1                if indeg[id(nxt)] == 0:                    q.append(nxt)        return order  class DataflowMapper(object):    """把计算图映射到 4x4 的 PCU 网格，并支持稀疏跳过。"""     def __init__(self, rows=4, cols=4):        self.rows = rows        self.cols = cols        self.grid = [[None for _ in range(cols)] for _ in range(rows)]     def place(self, op, r=0, c=0):        self.grid[r][c] = op.name     def run(self, graph, feed):        order = graph.topo_order()        values = dict()        compute_count = 0        for op in order:            if op.kind == 'matmul':                x = values[op.ins[0].name]                w = op.weight                mask = np.abs(w) > 1e-6                values[op.name] = x @ np.where(mask, w, 0.0)                compute_count += int(mask.sum())            elif op.kind == 'relu':                x = values[op.ins[0].name]                values[op.name] = np.maximum(x, 0.0)                compute_count += int(x.size)            elif op.kind == 'add':                a = values[op.ins[0].name]                b = values[op.ins[1].name]                values[op.name] = a + b                compute_count += int(a.size)            elif op.kind == 'output':                values[op.name] = values[op.ins[0].name]        return values, compute_count  def build_small_graph():    g = Graph()    x = g.add_op(Op('x', 'input'))    w1 = np.random.randn(4, 4)    w1[w1 < 0.5] = 0.0  # 制造稀疏权重    m1 = g.add_op(Op('m1', 'matmul', w1))    r1 = g.add_op(Op('r1', 'relu'))    m2 = g.add_op(Op('m2', 'matmul', np.random.randn(4, 4)))    out = g.add_op(Op('out', 'output'))    g.add_edge(x, m1)    g.add_edge(m1, r1)    g.add_edge(r1, m2)    g.add_edge(m2, out)    return g  if __name__ == '__main__':    g = build_small_graph()    mapper = DataflowMapper()    mapper.place(g.ops[1], 0, 0)    mapper.place(g.ops[2], 0, 1)    mapper.place(g.ops[3], 1, 0)    feed = {'x': np.random.randn(4, 4)}    values, cnt = mapper.run(g, feed)    total = 4 * 4 * 4 + 4 * 4 + 4 * 4    print('mapped ops:', [op.name for op in g.topo_order()])    print('compute count:', cnt, '/', total)    print('sparsity ratio:', round(1 - cnt / total, 3))    print('output shape:', values['out'].shape)

1. class DataflowMapper(object):模拟编译器的位置选择阶段，把算子放到 PCU 网格的指定行列。
2. mask = np.abs(w) > 1e-6编译器离线识别零权重，构建稀疏掩码，它决定了哪些计算可以跳过。
3. compute_count += int(mask.sum())只统计非零权重的乘加次数，直观反映稀疏跳过省下的计算量。
4. values[op.name] = x @ ...数据流执行的本质：上游算子输出直接作为下游算子输入，无需全局内存读写。
5. graph.topo_order()编译器先做拓扑排序，得到算子的调度顺序，后续沿此顺序生成路由。
6. w1[w1 < 0.5] = 0.0模拟模型训练后的稀疏权重，对应正文中静态剪枝的场景。

常见误区

面试题