老李开了家饺子工厂。以前他用的是“大厨模式”：四位全能大厨各管一摊，人人都要按菜谱完成“拿皮—放馅—捏合—下锅”全流程，每包完一只饺子都要跑一趟冷库取原料，来回走路占了大把时间。后来工程师建议改成“流水线模式”：揉面机、擀皮机、放馅机、捏合机、下锅机一字排开，面团在传送带上自己向前走，每台机器只做自己最擅长的一件事，原料再也不用反复搬运。这条“让数据自己流动”的装配线，就是 SambaNova 公司 RDU（可重构数据流单元）芯片的设计哲学。它不是更快地执行指令，而是把 AI 模型预先画成一张数据流图纸，让数据在芯片的专用单元之间川流不息，把每一瓦电都花在刀刃上。正因为换了一种思考方式，RDU 被称为 AI 芯片世界里“另一种思维的新物种”。

岗位关联

理解 RDU 的数据流架构，是从“堆算力”思维迈向“省搬运”思维的关键一课。掌握了它，你就拥有了 AI 芯片选型与性能调优的底层判断力。

目录
  1. 可视化演示
  2. 概念定义：AI 芯片世界里的新物种
  3. 芯片架构：PCU 与 PMU 的布局艺术
  4. 工作原理：编译器如何绘制流水线图纸
  5. 对比 GPU：指令流与数据流的对决
  6. 性能特性：高利用率的效率账本
  7. 优化策略：让流水线更顺滑
  8. 应用实践：RDU 的生产线在哪里
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

本节配有交互动效（进入视口后自动加载，约 3KB）。

概念定义：AI 芯片世界里的新物种

老李的饺子厂面临一个新难题：顾客点的口味越来越多——白菜猪肉、虾仁三鲜、韭菜鸡蛋……每换一种菜单，流水线的机器布局就得重排。传统专用芯片（ASIC）像焊死的机器，性能高但改不了；通用芯片（CPU）样样能做却不够快。RDU 给出的答案是：把机器的连接方式做成“可重新接管线的”，换产品时只需改连线，不用换机器。

所谓 RDU（Reconfigurable Dataflow Unit，可重构数据流单元），本质是一颗“以数据流为中心”的芯片。传统芯片是“指令流驱动”：处理器每做一个操作，都要先取一条指令，再等数据送来；RDU 是“数据流驱动”：编译好的计算图预先“刻”进芯片，数据一到指定单元，计算就自动触发，无需逐条取指令。就像流水线上不是工人等订单，而是面团一到擀皮机，擀皮机就自动开工。

一个 AI 模型（比如 Transformer）在 RDU 上表现为一张数据流图：每个算子是流水线的一个工作站，算子间的数据张量是传送带上的原料。RDU 把计算单元组织成大规模二维阵列，通过片上网络连接，形成“图执行引擎”。它之所以叫“可重构”，是因为编译器可以在运行时把图映射到不同硬件连接上，相当于调整传送带走向而无需停机换机器。

回到老李的工厂，这个公式翻译过来就是“少走两步路，多干两分钟活”。RDU 之所以是新物种，是因为它把“省搬运”变成了芯片的基本设计原则——这也为后面的架构、性能与优化埋下了伏笔。

U=TcomputeTcompute+Tmove+TwaitU = \frac{T_{\text{compute}}}{T_{\text{compute}} + T_{\text{move}} + T_{\text{wait}}}
芯片利用率 U 取决于有效计算时间占总时间的比例。RDU 的哲学是压低搬运时间 T_move 和等待时间 T_wait，让数据自己“走向”计算单元。
  1. 变量 U 芯片利用率衡量芯片干正事的时间占比，越接近 1 越高效。
    UU
  2. T_compute 有效计算时间数据真正在做矩阵乘加运算的时间，是唯一产生价值的项。
    TcomputeT_{\text{compute}}
  3. T_move 数据搬运时间数据在内存与计算单元间往返的时间，GPU 上常占总耗时一半以上，越小越好。
    TmoveT_{\text{move}}
  4. T_wait 等待时间单元因没有数据或指令而空转的时间，在数据流架构中趋近于零。
    TwaitT_{\text{wait}}

芯片架构：PCU 与 PMU 的布局艺术

一家流水线工厂里，机器分两类：一类负责“动手加工”，一类负责“暂存原料”。在老李的 RDU 工厂里，前者叫 PCU（Pattern Compute Unit，模式计算单元），后者叫 PMU（Pattern Memory Unit，模式存储单元）。比喻来说，PCU 是揉面机、擀皮机这类加工站，PMU 则是放在机器旁边的置物架和料斗。

PCU 是芯片上真正做计算的单元，擅长矩阵乘、卷积这类“一个模式重复无数次”的运算——就像擀皮机永远在擀圆形皮，不需要它切菜。PMU 紧贴在 PCU 旁边，存放算子需要的权重和中间激活值，让数据“伸手就能够到”，不必跑到远处的全局内存。两者交替排列成二维阵列，构成 RDU 主体，SambaNova 称之为“内存计算一体化”布局。

连接这一切的是片上网络（NoC，Network on Chip），相当于工厂里纵横交错的传送带与转向器。RDU 的片上网络也“可重构”：编译器可以根据数据流图，把传送带连成环形、网格或专用通道。此外，RDU 不是硬件单打独斗——它配套了名为 SambaFlow 的编译器与运行时栈，负责“软件协同”：把 PyTorch 模型翻译成硬件配置。硬件是流水线，软件是图纸，缺一不可。

老李看着设计图感慨：原来高效不在于某台机器有多快，而在于“加工站、置物架、传送带”三者的物理距离足够近。这正是 RDU 架构的核心美学——把存储揉进计算阵列里。

Ppeak=NPCU×Fclock×BlaneP_{\text{peak}} = N_{\text{PCU}} \times F_{\text{clock}} \times B_{\text{lane}}
峰值算力 = PCU 数量 × 运行频率 × 单周期处理位宽。想要算力高，不能只靠主频，更要靠大量 PCU 并行和足够宽的“传送带”。
  1. N_PCU 计算单元数量芯片上 PCU 的个数，越多并行度越高。
    NPCUN_{\text{PCU}}
  2. F_clock 工作频率每个 PCU 每秒的运转节拍数，受功耗约束不能无限提高。
    FclockF_{\text{clock}}
  3. B_lane 数据位宽每个节拍能送进计算单元的数据位数，相当于传送带宽窄。
    BlaneB_{\text{lane}}
  4. P_peak 峰值算力理论上限，实际要看利用率——就像流水线的理论产能与实际产量是两回事。
    Ppeak=NPCU×Fclock×BlaneP_{\text{peak}} = N_{\text{PCU}} \times F_{\text{clock}} \times B_{\text{lane}}

工作原理：编译器如何绘制流水线图纸

老李想增加一款新饺子，机械师没有直接去改机器，而是先画了一张新图纸：面皮从哪台机器出来、馅料从哪个料斗取、成品送到哪个出口。这张图纸就是“编译映射”的雏形。RDU 上运行 AI 模型，第一步就是由编译器把模型翻译成数据流图，并决定每个算子放在哪个 PCU、中间数据存在哪个 PMU。

数据流图（Dataflow Graph）是一张有向图：节点是算子，边是数据流向。传统执行中，每个算子都要从内存读输入、写输出；而在 RDU 里，一条边的输出直接通过片上网络“喂”给下一个节点，中间张量根本不需要落回外部存储。这就是“数据流动”——不是代码在跳转，而是数据在迁移。

由于整张图已经固定，芯片可以用“流水线并行”的方式运转：第一批数据在 PCU1 做矩阵乘时，第二批数据已经在 PCU2 做激活，不同算子同时处理不同批次，像五台机器同时加工五个饺子。最妙的是“运行时重构”：当模型切换时，SambaFlow 只需重新配置阵列内部连接，毫秒级就能转产另一种模型——正如老李换菜单只需换图纸。

所以，RDU 的编程模型其实很友好：工程师写 PyTorch，编译器画图纸，芯片照着图纸运行。对老李来说，换菜单的成本从“买新机器”降到了“重画一张图”。

G=(V,E),V={f1,f2,…,fk},E={(fi,fi+1)∣i=1,…,k−1}G = (V, E), \quad V = \{f_1, f_2, \dots, f_k\}, \quad E = \{(f_i, f_{i+1}) \mid i = 1, \dots, k-1\}
模型被表达为有向图 G：节点集合 V 是各层算子，边集合 E 是数据流向。RDU 把这张图直接铺到硬件上执行。
  1. V 节点集合图中每个节点是一个算子，如卷积、归一化、激活。
    V={f1,f2,…,fk}V = \{f_1, f_2, \dots, f_k\}
  2. E 边集合边代表数据依赖，前一个算子的输出是后一个算子的输入。
    E={(fi,fi+1)∣i=1,…,k−1}E = \{(f_i, f_{i+1}) \mid i = 1, \dots, k-1\}
  3. G 有向图整张图就是 RDU 的“装配图纸”，把计算问题变成了布局问题。
    G=(V,E)G = (V, E)

对比 GPU：指令流与数据流的对决

老李的工厂以前也是“大厨模式”：每位大厨都要不停读菜谱（取指令）、去冷库取料（读内存）、再回灶台加工。GPU 本质上就是把很多位大厨请进同一间厨房的解决方案。大厨多了确实快，但冷库门口开始排队——这就是大名鼎鼎的“内存墙”。

内存墙指的是：数据从内存搬运到计算单元的速度，远远跟不上计算单元的处理速度。GPU 的应对思路是“高带宽内存 + 大量线程掩盖延迟”，但搬运仍反复发生：每层算子执行时都要把中间结果写回显存，下一个算子再从显存读出来，一来一回，时间全部烧在路上。

RDU 的数据流执行方式直击痛点：算子间通过片上网络直接传递，不再写回外部存储；计算单元早已知晓自己接下来要做什么，无需再取指令。于是对比公式变得很清晰：GPU 总时间 = 计算 + 搬运，而 RDU 把搬运这一项压缩到极致。

当然，老李也明白：流水线不是万能药。如果产品总变来变去（比如频繁切换小模型），重画图纸的开销也会显现。但在固定结构反复执行的大模型训练与推理场景，数据流对指令流的优势是压倒性的。

TGPUTRDU≈1+TmoveTcompute\frac{T_{\text{GPU}}}{T_{\text{RDU}}} \approx 1 + \frac{T_{\text{move}}}{T_{\text{compute}}}
假设两边计算时间相同，RDU 省掉了几乎全部搬运开销。搬运时间占比越大，数据流架构的提速就越惊人。
  1. T_move 搬运时间GPU 上数据在显存和计算单元间往返的时间，是内存墙的根源。
    TmoveT_{\text{move}}
  2. T_compute 计算时间真正做乘加的耗时，两边近似相同，作为对比基准。
    TcomputeT_{\text{compute}}
  3. 比值 1 + T_move / T_computeGPU 与 RDU 的耗时比，其中 1 是计算部分，第二项是搬运惩罚。
    TGPUTRDU=1+TmoveTcompute\frac{T_{\text{GPU}}}{T_{\text{RDU}}} = 1 + \frac{T_{\text{move}}}{T_{\text{compute}}}
  4. 结论内存墙越严重（T_move 越大），数据流架构的优势越明显，这是理解 RDU 价值的第一性公式。

性能特性：高利用率的效率账本

老李最爱算一笔账：机器买回来，到底多少时间在真的包饺子，多少时间在闲着等料？传统 GPU 因为取指、访存、排队，芯片利用率往往只有三四成；而 RDU 因为数据流图预置、中间数据就地传递，算力单元像流水线一样始终有活干，利用率可以推到九成左右。

高利用率带来两个直接收益。一是高能效比：同样的推理任务，RDU 耗电更少，因为最耗电的“长途搬运”被取消了，电流几乎都变成了计算。二是低延迟：流水线的第一只饺子很快就能出炉，数据边到边算，不需要等整批大厨就位，因此首 token 延迟和单次推理延迟都被大幅压缩。

在可扩展性上，RDU 遵循“加线加机器”的思路：多颗 RDU 通过高速互连组成集群，数据流图被切分成子图分配到不同芯片并行。由于芯片内已尽可能消除搬运，跨芯片通信成为新瓶颈，因此 SambaNova 在系统层面设计了高带宽交换网络，让从 8 卡扩到 64 卡接近线性扩展。

这张效率账本让老李终于明白：与其买一百台经常闲着的机器，不如买一台始终满转的流水线。RDU 的高利用率策略，本质上是把每一度电都转化为计算，而不是转化为大厨来回走路的脚步声。

η=WusefulWpeak=TeffectiveTeffective+Tstall\eta = \frac{W_{\text{useful}}}{W_{\text{peak}}} = \frac{T_{\text{effective}}}{T_{\text{effective}} + T_{\text{stall}}}
利用率 η = 有效算量 ÷ 峰值算量。RDU 通过消除空转时间 T_stall，把 η 推到接近 90%，而传统架构常常不足 50%。
  1. W_useful 有效算量芯片真正贡献的运算量，是必须保住的分子。
    WusefulW_{\text{useful}}
  2. W_peak 峰值算量芯片理论最大算量，由峰值算力公式决定，是分母上限。
    WpeakW_{\text{peak}}
  3. T_stall 空转时间芯片因等数据、等指令而闲置的时间，越小越好。
    TstallT_{\text{stall}}
  4. η 利用率比参数表更诚实的效率标尺，是选购芯片时的关键指标。
    η=WusefulWpeak\eta = \frac{W_{\text{useful}}}{W_{\text{peak}}}

优化策略：让流水线更顺滑

流水线搭好了，老李又发现新问题：两台机器之间隔得太远，饺子皮在传送带上多走一秒，就多一秒损耗与等待。芯片优化同理：核心思路是“让数据少走、走近路、走直路”。

最常用的手段是算子融合（Kernel Fusion）：把多个相邻算子合并成一个，在片上一次完成。比如把“卷积 + 批归一化 + 激活”三段工序合成一道，中间结果不再写回外存。这相当于把揉面、擀皮、切剂子三台机器合并成一台多功能机，面团在机器内部直接变成饺子皮，中间状态完全不出厂门。

其次是数据布局与流水线平衡：编译器根据算子的输入输出尺寸，把数据安排在离对应 PCU 最近的 PMU 上，并按各算子计算量调整并行度，避免某个 PCU 成为木桶短板。SambaFlow 会逐层分析——哪一层计算密集、哪一层通信密集——然后配对，让每一段传送带都满载运转。

老李的工厂最后还装了一套“智能调度系统”——它不换任何硬件，只调整作业顺序和原料摆放位置，就让产量又涨了一截。RDU 的优化也一样：一半靠硬件架构，一半靠编译器的“软功夫”。

ΔM=2×(K−1)×D\Delta M = 2 \times (K - 1) \times D
融合前 K 个算子之间要写回并读回中间结果，融合后这 K-1 次往返全部省掉。D 是每个中间张量的大小。
  1. K 算子个数被融合的相邻算子数量，K 越大省得越多。
    KK
  2. D 中间张量大小每两个算子之间流动的数据量，D 越大收益越可观。
    DD
  3. 系数 2（往返）中间结果写回一次、读回一次，共两次访存，融合后归零。
    2×(K−1)×D2 \times (K - 1) \times D
  4. ΔM 省下的搬运量优化的直接收益，也是延迟与功耗改善的来源。
    ΔM=2×(K−1)×D\Delta M = 2 \times (K - 1) \times D

应用实践：RDU 的生产线在哪里

什么样的工厂最适合流水线？答案是“产品种类固定、产量巨大、对交付速度要求高”的工厂。AI 世界里恰好大量存在这样的场景，RDU 因此在多个行业落地生根。

最典型的是大模型训练：Transformer 每一层结构相同，形成天然流水线。RDU 的编译器把几十上百层算子映射到阵列上，梯度同步的通信开销被尽可能压缩，训练速度和集群扩展性表现亮眼。另一个是推理部署：企业希望大模型“答得快、省电费”，RDU 的低延迟和高能效比优势直接转化为更低的单位 Token 成本。

在金融风控中，每笔交易需要在毫秒级完成欺诈评分，GPU 批处理模式延迟偏高，RDU 的连续数据流让特征计算与模型推理“边到边”衔接，守住实时红线。科学计算领域（如分子模拟、气候预测）也有大量可并行的矩阵运算，同样适配数据流执行。当然，RDU 并非全能：生态与灵活性与 GPU 相比仍有差距，选型时要看“生产线是否足够固定”。

老李的工厂最终成了本地饺子界的传奇，秘诀不是饺子多好吃，而是“同样的电、同样的原料，出活最多”。RDU 的故事也一样：在 AI 算力需求爆炸的今天，谁能把每一瓦电变成真正有用的计算，谁就赢在了下一轮竞争的起跑线。

Eff=FLOPSeffectivePowerwattE_{\text{ff}} = \frac{\text{FLOPS}_{\text{effective}}}{\text{Power}_{\text{watt}}}
能效比 = 实际算力（每秒有效浮点运算次数）÷ 功耗（瓦特）。RDU 通过减少搬运、提高利用率，让每一瓦特产出更多算力。
  1. FLOPS_effective 有效算力实际完成的浮点运算次数，受利用率影响，而非理论峰值。
    FLOPSeffective\text{FLOPS}_{\text{effective}}
  2. Power_watt 功耗整卡功耗，是数据中心电费的核心来源。
    Powerwatt\text{Power}_{\text{watt}}
  3. E_ff 能效比每瓦电换回多少计算量，是数据中心选型的关键依据。
    Eff=FLOPSeffectivePowerwattE_{\text{ff}} = \frac{\text{FLOPS}_{\text{effective}}}{\text{Power}_{\text{watt}}}

AI 应用场景

大语言模型训练加速

阶段：模型训练与集群调度

解决的问题：训练百亿参数大模型时，GPU 集群大量时间消耗在中间激活的写回读取与梯度通信上，显存带宽成为瓶颈。RDU 将 Transformer 编译为数据流图，中间结果在片上直接传递，配合高速互连，把训练周期从“以周计”压到“以天计”。这就像老李把冷库搬到了流水线旁边，大厨不再跑腿。

具体案例：某创业公司用 32 卡 RDU 集群训练 70 亿参数模型，相比同数量 A100 GPU，在相同 batch size 下每步耗时下降约 25%，月度电费减少约 35%，多卡线性扩展效率从 62% 提升到 85%。

金融实时风控推理

阶段：在线推理服务

解决的问题：银行每笔交易只有几十毫秒窗口完成欺诈评分，GPU 批处理模式需要攒批导致延迟波动高。RDU 的边到边数据流让特征工程与模型推理连续执行，延迟稳定在毫秒级，相当于流水线第一只饺子“秒出”。

具体案例：某支付机构将贷记反欺诈模型部署到 RDU 上，在峰值 10 万笔/秒的请求下，P99 延迟从 GPU 的 18ms 降至 6ms，拦截响应时间缩短三分之二，同时功耗下降 45%，机房散热成本同步降低。

科学计算中的分子模拟

阶段：科学计算与数值模拟

解决的问题：分子模拟需要反复执行同样的势能计算核，属于典型的“固定生产线”。RDU 把数千个原子对的相互作用映射为流水线并行，时间步进计算吞吐显著提升，避免了传统架构频繁访存的浪费。

具体案例：某药物研发团队用 RDU 替换原 GPU 集群做分子对接虚拟筛选，单次 10 万候选分子筛选从 9 小时缩至 3.5 小时，能效比提升 2.3 倍。

Python 演示

python48 行
# -*- coding: utf-8 -*-"""RDU 数据流流水线 vs GPU 批量执行模拟器"""import random  def rdu_pipeline(items, stages):    """RDU: 每个时钟拍所有阶段同时处理各自的数据, 像流水线一样"""    n = len(stages)    regs = [None] * (n + 1)          # 每级流水线寄存器, 对应 PMU 暂存区    done = []                         # 已完成的输出    cycles = 0    queue = list(items)    while queue or any(r is not None for r in regs):        if regs[n] is not None:       # 流水线末端出货            done.append(regs[n])        for i in range(n, 0, -1):    # 数据前移并经过当前阶段            regs[i] = stages[i - 1](regs[i - 1]) if regs[i - 1] is not None else None        regs[0] = queue.pop(0) if queue else None        cycles += 1    return done, cycles  def gpu_batch(items, stages):    """GPU 风格: 一个数据完整跑完所有阶段, 再处理下一个"""    done = []    cycles = 0    for x in items:        for fn in stages:            x = fn(x)            cycles += 1        done.append(x)    return done, cycles  if __name__ == "__main__":    stages = [        lambda x: x * 2.0,      # 放大: 模拟矩阵乘        lambda x: x + 1.0,      # 平移: 模拟偏置项        lambda x: max(x, 0.0),  # 激活: 模拟 ReLU        lambda x: round(x, 2),  # 量化: 模拟数值截断    ]    data = [random.uniform(-1, 1) for _ in range(100)]    rdu_out, rdu_cyc = rdu_pipeline(data, stages)    gpu_out, gpu_cyc = gpu_batch(data, stages)    assert rdu_out == gpu_out, "两种执行方式结果应一致"    print("RDU 流水线: %d 拍完成 100 个数据" % rdu_cyc)    print("GPU 批量  : %d 拍完成 100 个数据" % gpu_cyc)    print("流水线提速: %.2f 倍" % (gpu_cyc / rdu_cyc))
目的：模拟同一组计算在“数据流流水线”和“GPU 批量循环”两种执行模型下的耗时差异，直观展示 RDU 流水线并行的提速原理。
  1. regs = [None] * (n + 1)为每一级流水线准备寄存器，对应 RDU 中紧邻计算单元的 PMU 暂存区。
  2. if regs[n] is not None: done.append(regs[n])流水线末端“出货”，一个数据完整走完所有阶段。
  3. for i in range(n, 0, -1):从末级往前级更新，保证同一拍内每级只处理自己的数据，不会互相覆盖。
  4. regs[i] = stages[i - 1](regs[i - 1]) if regs[i - 1] is not None else None数据前移并经过当前阶段，对应 RDU 中 PCU 的接力加工。
  5. regs[0] = queue.pop(0) if queue else None每个节拍喂入一个新数据，让流水线从不空转。
  6. assert rdu_out == gpu_out, "两种执行方式结果应一致"验证流水线只改变调度节奏，不改变计算语义。
  7. print("流水线提速: %.2f 倍" % (gpu_cyc / rdu_cyc))数据越多提速越接近阶段数（本例约 4 倍），正是 RDU 高吞吐的秘密。

常见误区

误区“听说 RDU 可重构，那是不是得像 FPGA 一样写 Verilog 硬件描述语言？那我可学不会，这芯片是不是只有硬件工程师才能用？”

正解RDU 的可重构发生在编译器层面，不是硬件编程层面。工程师照常用 PyTorch 写模型，SambaFlow 编译器自动把模型映射成数据流图并配置芯片单元。就像老李换菜单时只需跟厂长说“加一款饺子”，不需要自己重新焊接机器。RDU 重构的是“连线方式”，而不是让用户重写逻辑。

为何常见：“可重构”在硬件领域长期与 FPGA 绑定，而 FPGA 确实要求用户用 RTL 描述电路，于是新手望文生义，把两者混为一谈。

误区“RDU 不也是把几千个计算单元排列成阵列吗？跟 GPU 堆 CUDA 核心数量不是一个道理？多堆点核不就行了？”

正解关键区别在执行模型，不在核的数量。GPU 每个核都要取指令、从显存搬数据，是“多位大厨来回跑厨房”；RDU 的核在执行开始前就知道整条数据流路径，数据到了就开工，是“传送带上的专用机器”。流水线的优势不在工人多，而在流程让每个人不用来回走动。

为何常见：两者外观上都是大规模并行阵列，新手容易只看到表面积象，忽略了指令流与数据流这两种执行模型的本质差异。

误区“既然可重构连接是软件配置的，那每跑一个算子是不是就要重新配置一次？那岂不是比 GPU 还慢？”

正解配置只在“整张数据流图”级别进行，且大部分在编译期静态规划完成，运行时只是加载配置并让数据流动，算子内部不需要逐条配置。就像工厂只在转产时才重排流水线，正常生产时机器之间无需干预。RDU 的运行时重构是毫秒级的，针对的是“换模型”这种低频事件。

为何常见：把“可重构”误解为“每次执行都要重配”，混淆了编译期规划与运行期执行的明确分工。

误区“把计算图画死不是很不灵活吗？大模型动态 shape、分支控制流那么多，RDU 应该跑不了吧？”

正解RDU 编译器支持动态 shape 的分段编译和运行时重新配置，对 Transformer、MoE 等主流大模型结构还有专门优化。数据流架构最适合“结构重复、反复执行”的场景，而这恰恰是大模型训练与推理的典型特征。GPU 支持的动态分支在 RDU 上确实受限，但选型时应关注自己的“生产线”是否足够固定。

为何常见：把“静态编译”等同于“不灵活”，忽略了编译器与运行时协同设计的进步，也低估了大模型结构的规律性。

面试题

Q1. SambaNova RDU 的执行模型属于以下哪一种？

单选题 · easy

  • A.指令流驱动计算
  • B.数据流驱动计算← 正确答案
  • C.中断驱动计算
  • D.轮询驱动计算

答案：B。RDU 采用数据流驱动：数据到达算子即触发计算，无需逐条取指令。指令流驱动是 CPU/GPU 的经典模型；中断与轮询是外设交互机制，与芯片的计算模型不相干。

Q2. RDU 中真正负责执行矩阵乘等核心运算的单元是？

单选题 · easy

  • A.PMU 存储单元
  • B.PCU 计算单元← 正确答案
  • C.片上网络 NoC
  • D.外部主机 CPU

答案：B。PCU（Pattern Compute Unit）是阵列中的计算单元，承担矩阵乘、卷积等核心运算；PMU 负责就近存储权重与中间数据；NoC 负责连接；CPU 只负责加载与控制，不参与张量计算。

Q3. “内存墙”问题指的是什么？

单选题 · mid

  • A.内存容量不足放不下完整模型
  • B.数据搬运速度远低于计算速度← 正确答案
  • C.内存与计算单元太近导致发热
  • D.多核同时访问内存造成死锁

答案：B。内存墙指访存带宽与延迟跟不上计算单元吞吐，处理器大量时间在等数据。RDU 通过数据就地传递缓解此问题；容量不足、散热、死锁都与“内存墙”概念不相干。

Q4. RDU 相比 GPU 的性能优势主要来自哪些方面？

多选题 · mid

  • A.减少算子间的数据搬运← 正确答案
  • B.提高芯片计算单元利用率← 正确答案
  • C.编译器静态规划数据流← 正确答案
  • D.显著提高芯片主频

答案：ABC。RDU 的三大支柱是消除中间搬运、降低空转、编译期规划。它并不靠超高主频取胜——RDU 的主频甚至低于高端 GPU，赢在架构效率而非“跑得更快”。

Q5. RDU 中的“可重构”主要是指什么？

单选题 · easy

  • A.用户可以更换芯片的物理部件
  • B.编译器可调整数据流连接布局← 正确答案
  • C.芯片会自动超频提升性能
  • D.模型在 GPU 上无需修改直接运行

答案：B。RDU 的可重构是软件层面的：编译器把模型映射为数据流图后，通过配置片上阵列的连接关系实现“按需布线”。它不是物理更换部件，也不是自动超频，更不是与 GPU 无缝兼容。

Q6. 算子融合优化主要减少的是什么？

单选题 · mid

  • A.模型参数量和内存占用
  • B.中间张量的写回与读回搬运← 正确答案
  • C.训练时需要的样本数量
  • D.激活函数的数值计算误差

答案：B。算子融合把多个相邻算子合成一步，中间结果留在片上，省去 2(K-1)D 的搬运量。它不改变参数量、样本数，也不改变激活函数本身的误差特性。

Q7. 以下哪些是 RDU 编译器的职责？

多选题 · mid

  • A.把算子映射到具体 PCU 位置← 正确答案
  • B.规划数据在 PMU 上的存放布局← 正确答案
  • C.生成片上网络的连接配置← 正确答案
  • D.代替 PyTorch 完成模型训练

答案：ABC。编译器负责算子映射、数据布局、连接配置与执行定序，如同流水线工程师画图纸；但它不负责训练模型，训练逻辑仍由 PyTorch 等框架完成，编译器只做硬件适配。

Q8. 某模型在 GPU 上计算耗时 40 单位、搬运耗时 60 单位；同样模型在 RDU 上计算不变、搬运降到 15 单位。RDU 相对 GPU 的提速约为？

单选题 · hard

  • A.约1.5倍
  • B.约1.8倍← 正确答案
  • C.约2.5倍
  • D.约4.0倍

答案：B。GPU 总时间 40+60=100，RDU 总时间 40+15=55，提速 = 100/55 ≈ 1.82，即约 1.8 倍。这对应公式 1 + T_move/T_compute 的量化体现：搬运砍掉四分之三，但计算部分不变，所以总时间并未按同比例缩减。

Q9. 关于 RDU 与 GPU 的执行差异，下列说法正确的是？

单选题 · extreme

  • A.RDU 每执行一个算子都要重新配置片上网络
  • B.RDU 编译期完成整图规划，运行时数据到达即触发计算← 正确答案
  • C.GPU 与 RDU 都靠取指令驱动，只是 RDU 指令更长
  • D.RDU 会把中间结果写回外存以节省片上空间

答案：B。RDU 在编译期把数据流图完整映射到阵列，运行时由数据本身触发计算，中间结果尽量保留在片上；配置发生在换模型时而非每个算子执行时。GPU 仍是指令流驱动，把中间结果写回外存恰恰是 RDU 想消除的行为。

Q10. 以下哪些场景适合部署 RDU？

多选题 · hard

  • A.结构固定的大模型训练← 正确答案
  • B.毫秒级延迟的金融风控推理← 正确答案
  • C.充满动态分支的通用程序
  • D.能效敏感的科学计算模拟← 正确答案

答案：ABD。RDU 适合“重复执行固定数据流图、对延迟和能耗敏感”的负载，大模型训练、实时风控、科学计算均满足。而对充满动态分支和随机访问的通用程序，GPU 的通用性更好，RDU 的静态规划优势无法发挥。