想象你住的小区里新开了一家“超级中央厨房”——名为燧原GCU。这家厨房不炒家常菜，专攻AI大餐：一句话生成图片、大模型聊天、自动驾驶识别路况……只要把“食材”（数据）送进去，它就能按预定菜谱高速出菜。和隔壁英伟达家的大厨房（GPU）不同，这家厨房不负责煎炸炒炖的杂活（图形渲染仅保留基础能力），而是把火力集中在AI最爱的“硬菜”上——矩阵乘法、卷积、注意力机制。为什么叫“中央厨房”？因为它把数千个“厨师”（计算核心）、多层“冷库与案板”（存储层次）、“传送带”（片内互联）整合在一块芯片上，形成了一个为AI量身定制的流水线。这篇文章，我们一边参观这间厨房，一边把燧原GCU的架构原理、性能特性和优化策略弄明白。

岗位关联

理解燧原GCU的架构设计，能帮你在国产AI芯片选型、算力部署与模型迁移中做出更专业的工程决策，是AI基础设施方向从业者的必备能力。

目录
  1. 可视化演示
  2. 一、架构定位：超级厨房的选址与经营范围
  3. 二、异构计算核心：三类厨师的班组协作
  4. 三、存储层次体系：冷库、中转站与操作台
  5. 四、片内互联设计：传送带与传菜电梯
  6. 五、软件栈体系：菜谱中枢与翻译官
  7. 六、性能优化策略：主厨的排班与调度艺术
  8. 七、生态对比与选型：各家厨房的风格之争
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

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

一、架构定位：超级厨房的选址与经营范围

这家“超级中央厨房”开在数据园区里，专接 AI 订单。它不像街边小饭馆（CPU）什么菜都炒，也不像全能大酒店（GPU）既做图形渲染又做科学计算——它把菜单精简到极致：深度学习中的卷积、矩阵乘法、注意力机制等“张量硬菜”。这一定位，术语叫 AI 加速器（AI Accelerator） ，是一种专为神经网络计算设计的处理器。燧原 GCU（General Computing Unit，通用计算单元）就是其中的国产代表，属于“AI硬件与算力”生态中的自主创新力量。

从概念上理解，GCU 与 GPU 同属于并行计算芯片，但经营思路不同。GPU 出身于图形渲染，之后才被发现适合通用计算，因此保留了大量与 AI 无关的功能；而 GCU 从设计第一天就只为 AI 服务，砍掉了图形管线等冗余电路，把晶体管的预算全部投向矩阵运算与数据搬运。这就像一家厨房把厨具全部换成大铁锅和猛火灶，不做西点，只炒硬菜，出菜效率自然更高。

判断一个 AI 加速器是否“划算”，最常用的指标是 计算访存比（Arithmetic Intensity） ，即每搬运一个字节数据，能做多少次浮点运算。它决定了加速器是“算力饥饿”还是“带宽饥饿”。

回看这间厨房的定位：正是因为 AI 任务天然具有高计算访存比（矩阵乘法中数据可反复复用），GCU 才敢把大量晶体管留给算力单元，把带宽引擎（HBM）作为配套加速器。定位清晰，是它立足国产 AI 芯片生态的第一步。

AI=FLOPsBytes\displaystyle AI = \frac{FLOPs}{Bytes}
计算访存比像“一道菜的食材利用率”：如果一道菜只需 1 斤食材就能做出 8 斤重的成品，说明这个厨房的搬运效率极高。
  1. 分子 FLOPs（浮点运算次数）衡量计算工作量的单位，一次乘加各算一次。FLOPs 越大，说明任务越“烧脑”。
    FLOPs=浮点加法和乘法的总次数\displaystyle FLOPs = \text{浮点加法和乘法的总次数}
  2. 分母 Bytes（搬运字节数）数据从显存到计算单元之间搬运的总字节量。Bytes 越大，说明“来回取食材”的消耗越多。
    Bytes=所有访存操作的数据量之和\displaystyle Bytes = \text{所有访存操作的数据量之和}
  3. 比值含义AI 值越高，代表计算密度大、访存压力小，芯片设计时可以把更多资源倾斜给算力；AI 值低则反之。
    AI=FLOPsBytes→高则算力敏感，低则带宽敏感\displaystyle AI = \frac{FLOPs}{Bytes} \rightarrow \text{高则算力敏感，低则带宽敏感}

二、异构计算核心：三类厨师的班组协作

走进厨房后厨，你会发现这里不是一群全能厨师，而是三种分工明确的班组。第一类是 矩阵计算单元（Matrix Compute Unit） ，相当于“主厨”，专攻神经网络最核心的张量乘法——把大矩阵像切豆腐一样分块处理，以极高的吞吐量完成运算；第二类是 向量计算单元（Vector Compute Unit） ，相当于“配菜助手”，负责激活函数、归一化、逐元素操作这类节奏轻快的任务；第三类是 标量控制单元（Scalar Control Unit） ，相当于“传菜指挥”，负责循环、分支、地址计算等流程控制，决定前两类单元何时动手。这种“异构众核”设计，是 GCU 架构的灵魂。

异构的核心思想是“让合适的厨师做合适的菜”。通用处理器靠一套复杂电路应对所有任务，而 GCU 把电路拆分成多种专用执行单元，每个单元在自己的赛道做到极致。矩阵乘法是 AI 的“剁椒鱼头”，主厨一次能同时处理成千上万组乘加；向量单元则像刀工助手，一个指令对整批数据做同样操作；标量单元虽然算力弱，但它是整个厨房的“大脑皮层”，保证两百个工位有序不乱。

矩阵计算单元的吞吐量由单次矩阵乘法的运算量决定。假设它处理一块 $M \times N$ 的矩阵乘以 $N \times K$ 的矩阵，运算量为：

主厨的威力就藏在这个公式里：当 M、N、K 都很大时，运算量以三次方级别增长，而矩阵单元可以在一个时钟周期内完成成千上万次乘加。三种厨师各司其职、紧密配合——这就是 GCU 异构计算的本质：不是一锅乱炖，而是流水线式的大规模协作。

FLOPs=2×M×N×K\displaystyle FLOPs = 2 \times M \times N \times K
这个公式像“做一桌菜的工作量”：每道菜要处理 M 个主料、N 个配料，每个组合都要过一次火（乘）再加一次酱（加）。
  1. M 与 K（两个输入维度）第一个矩阵的行数和第二个矩阵的列数，决定输出矩阵的形状。
    A[M×N]×B[N×K]→C[M×K]\displaystyle A[M \times N] \times B[N \times K] \rightarrow C[M \times K]
  2. N（内积维度）两矩阵共享的维度，表示每个输出元素需要累加多少次乘法结果。
    Ci,j=∑n=1NAi,n×Bn,j\displaystyle C_{i,j} = \sum_{n=1}^{N} A_{i,n} \times B_{n,j}
  3. 系数 2（乘加各一次）每次内积累加都包含一次乘法和一次加法，所以总运算量是 $M \times N \times K$ 的两倍。
    FLOPs=2MNK\displaystyle FLOPs = 2MNK

三、存储层次体系：冷库、中转站与操作台

厨房的食材管理绝对是一门学问。GCU 的存储系统分为三层，对应着三种不同温度和取用速度的区域。最底层是 HBM 高带宽显存（High Bandwidth Memory） ，相当于地下大冷库，容量巨大（可达几十 GB），能囤积整个模型权重和中间结果，但“出库”速度相对慢，且离厨师远；中间层是 L2 缓存（二级缓存） ，相当于走廊里的中转冷柜，容量小很多但存取更快；最上层是 片上 SRAM（静态随机存取存储器） ，相当于每个厨师手边的操作台，速度快到极致，但空间极其有限，通常只有几 MB。

为什么一定要分这么多层？因为“快”和“大”是一对矛盾：SRAM 快到可以与计算单元同频运转，但成本极高；DRAM/HBM 便宜大碗，但延迟上千倍。芯片设计者必须让数据像流水一样从冷库一步步走到操作台，每一层都是为了“屏蔽上一层的高延迟”而存在的。术语 存储层次（Memory Hierarchy） 描述的就是这种分级缓存策略。

数据搬运的时间直接决定任务完成速度。搬运 $Q_{byte}$ 字节的数据，在有效带宽为 $B_{eff}$ 的条件下，所需时间为：

所以 GCU 设计者在一开始就引入了 HBM——它用极高的片外带宽撑住“冷库吞吐”，再配合大容量 L2 与 SRAM 把热点数据留在案板边。对我们做性能分析的人而言，只需要记住：每一次把数据从 HBM 搬到 SRAM，都是一次昂贵的“出库”操作，能省则省。

Tmem=QbyteBeff\displaystyle T_{mem} = \frac{Q_{byte}}{B_{eff}}
这个公式像“从冷库搬货到案板的时间”：货越多、电梯越慢，搬运耗时就越长。所以优化的核心不是把冷库变大，而是把每次搬货的量变小。
  1. Q_byte（搬运字节量）一次计算任务中需要从显存搬到核内的总数据量。重复使用的数据若能留在操作台，Q_byte 就会大幅下降。
    Qbyte=∑每次访存数据块大小\displaystyle Q_{byte} = \sum_{\text{每次访存}} \text{数据块大小}
  2. B_eff（有效带宽）实际达到的吞吐速度，受 HBM 峰值带宽、NoC 拥塞等因素影响，通常达不到理论峰值。
    Beff=η×Bpeak,0<η<1\displaystyle B_{eff} = \eta \times B_{peak}, \quad 0 < \eta < 1
  3. 整体耗时T_mem 越大，说明数据搬运越慢，计算核心就不得不“空等”食材上桌。
    Tmem=QbyteBeff∝搬运压力\displaystyle T_{mem} = \frac{Q_{byte}}{B_{eff}} \propto \text{搬运压力}

四、片内互联设计：传送带与传菜电梯

厨房再大，如果没有高效的传送系统，食材就会堵在走廊里。GCU 内部的几十个计算单元、数十个分布式 SRAM 和各级缓存之间，靠一张 片上网络（Network-on-Chip，NoC） 连接——它就像一套纵横交错的传送带和传菜电梯，取代了传统的“总线孤岛”模式。NoC 的特点是：不把所有设备挂一条共享总线上，而是像城市交通网一样，通过路由节点把数据包从一个核心搬到另一个核心，多个通道可以同时传输，互不干扰。

多卡互联同样重要。单颗芯片的算力终究有限，在训练千亿参数大模型时，需要把多张 GCU 卡组成集群。这时卡与卡之间通过高速互联链路（如类 NVLink 的高速 SerDes 通道）组成 多卡互联方案，配合集合通信库（如 Ring-AllReduce）把梯度汇总开销摊薄到整个集群。数据在这些节点间的路径由 数据路由机制 决定——路由算法要尽量走短路、避开拥塞，就像外卖骑手要躲开早晚高峰路段。

并行计算中有一个著名的“木桶效应”，描述互联效率对加速比的影响：

NoC 和多卡互联的意义，就是尽量提高 p 并降低通信开销，让加速比 S 更接近理想值。如果片内数据路由设计不佳，数据包在 NoC 上撞车，核心们就会像没收到食材的厨师一样干瞪眼。传送带有多通畅，这间厨房就有多高产。

S=1(1−p)+pN\displaystyle S = \frac{1}{(1 - p) + \dfrac{p}{N}}
这个公式叫 Amdahl 定律，像“多人抬钢琴”：真正能提速的部分（p）才有协作红利，如果 20% 的流程必须串行（比如把钢琴搬上楼），那再多的人也白搭。
  1. p（可并行比例）任务中能被多个核心同时处理的部分占比。矩阵乘法几乎 100% 可并行，而某些循环依赖则只能串行。
    p=可并行工作量总工作量\displaystyle p = \frac{\text{可并行工作量}}{\text{总工作量}}
  2. N（并行核心数）参与协作的计算单元数量。N 越大，理论并行能力越强。
    N=参与计算的核心或卡数\displaystyle N = \text{参与计算的核心或卡数}
  3. 分母结构$(1-p)$ 是不可并行的部分，$p/N$ 是并行部分均摊后的耗时。两者相加正是总耗时。
    S=1(1−p)+p/N(N→∞,S→11−p)\displaystyle S = \frac{1}{(1-p) + p/N} \quad (N \to \infty, S \to \frac{1}{1-p})

五、软件栈体系：菜谱中枢与翻译官

硬件再强，没有“菜谱”也是空转。GCU 的软件栈，相当于中央厨房的 菜谱中枢与翻译官系统。顶层是 燧原 SDK（软件开发工具包），为开发者提供一整套工具链——包括算子库、调试器、性能剖析器，就像给厨师发布的标准化菜谱手册；中间是 框架适配层，让 PyTorch、TensorFlow、OneFlow 等主流深度学习框架产出的计算图能够直接“落到”GCU 上执行；底层是 驱动与运行时（Driver & Runtime），负责把翻译好的指令真正调度到硬件上，管理显存、同步任务、启动内核。

用户写好的模型代码，本质上是一张计算图（Graph），图中每个节点抽象成算子（Operator）。框架适配层把算子下发给燧原的编译器，编译器再将高层描述翻译为 GCU 的底层机器指令。为了兼容 PyTorch 生态，GCU 提供了类 CUDA 的编程接口，让 CUDA 程序可以低成本迁移——好比给北方菜馆备了一套川菜菜谱，随时能接四川客人的单。整个流程的端到端延迟可以分解为启动开销与内核执行时间之和：

如果把芯片比作厨房，软件栈就是让所有厨师统一按照标准化流程干活的管理中枢。GCU 的国产价值不仅在于芯片本身，更在于这套从框架到驱动的全栈自主体系——有了它，用户迁移模型时才不至于“菜单都看不懂”。

Ttotal=Tlaunch+∑i=1KTkernel(i)\displaystyle T_{total} = T_{launch} + \sum_{i=1}^{K} T_{kernel}^{(i)}
这个公式描述了“上菜总时间”由“下单传菜”和“逐道烹饪”两部分构成。K 是菜品数量，每一道菜（内核）都要单独花时间。
  1. T_launch（启动开销）每一次内核启动都需要 CPU 侧做任务下发和设备端同步，属于不可避免的“下单”时间。
    Tlaunch=API调用 + 队列等待 + 上下文同步\displaystyle T_{launch} = \text{API调用 + 队列等待 + 上下文同步}
  2. 求和项（内核执行）计算图中的每个算子对应一次内核执行，耗时累加构成总计算时间。
    ∑i=1KTkernel(i)=Tkernel(1)+Tkernel(2)+⋯+Tkernel(K)\displaystyle \sum_{i=1}^{K} T_{kernel}^{(i)} = T_{kernel}^{(1)} + T_{kernel}^{(2)} + \cdots + T_{kernel}^{(K)}
  3. 减少 K 的意义算子融合可以把多个小内核合成一个大内核，既减少 T_launch 次数，也减少中间结果写回显存的开销。
    Ttotal↓⇐Kfused<Koriginal\displaystyle T_{total} \downarrow \Leftarrow K_{\text{fused}} < K_{\text{original}}

六、性能优化策略：主厨的排班与调度艺术

硬件架构是固定的，但如何用好它却大有学问。性能优化的核心目标只有一个：让计算单元尽量保持忙碌，减少空等。对应这间厨房，主厨要做三件事。第一是 算子融合（Operator Fusion）：把相邻的细粒度算子（比如“加偏置→激活函数→乘缩放”）合并成一个粗粒度算子，减少内核启动次数和中间结果的搬运。第二是 内存复用（Memory Reuse）：通过分块（Tiling）和多级缓冲，让同一块数据在 SRAM 或 L2 中被反复使用，而不是频繁回 HBM 冷库取。第三是 并行度调整（Parallelism Tuning）：合理配置线程块数量、流水线深度和计算单元的任务分配，避免某些核心超载、另一些闲置。

这些策略背后的理论模型就是 Roofline 模型：一个任务的实际执行时间不可能低于计算耗时和访存耗时的较大者。因为在硬件层面，计算单元和存储系统是并行运转的，二者谁更慢，谁就决定最终时间：

在 GCU 上做性能调优，实际上是解读这个 max：先用 profiler 判断任务是算力瓶颈还是带宽瓶颈，再对症下药。如果是带宽瓶颈，优先做算子融合、内存复用、加大分块尺寸；如果是算力瓶颈，则调整并行度、开启更激进的指令调度。主厨的智慧不在于多炒菜，而在于让每个灶台都恰好在最合适的时刻接到食材。

Texec=max⁡(WcompPpeak, QdataBpeak)\displaystyle T_{exec} = \max\left( \frac{W_{comp}}{P_{peak}},\ \frac{Q_{data}}{B_{peak}} \right)
这个公式像“接单出菜的下限”：厨房再快，如果食材在冷库里搬不出来，总时间就被搬运卡住；反之，搬运再顺，计算核心不够快，总时间也被计算卡住。
  1. W_comp / P_peak（计算耗时项）总计算量除以峰值算力，代表“算力全开”所需时间。
    WcompPpeak=总浮点运算量峰值 FLOPS\displaystyle \frac{W_{comp}}{P_{peak}} = \frac{\text{总浮点运算量}}{\text{峰值 FLOPS}}
  2. Q_data / B_peak（访存耗时项）总搬运字节数除以峰值带宽，代表“带宽拉满”所需时间。
    QdataBpeak=搬运总量峰值带宽\displaystyle \frac{Q_{data}}{B_{peak}} = \frac{\text{搬运总量}}{\text{峰值带宽}}
  3. max（瓶颈判断）真实耗时取两者较大值。算子融合与内存复用都是在压缩 Q_data，从而压低访存项。
    Texec=max⁡(计算时间,访存时间)\displaystyle T_{exec} = \max(\text{计算时间}, \text{访存时间})

七、生态对比与选型：各家厨房的风格之争

看完成内部结构，我们把镜头拉远：燧原 GCU 在国产 AI 芯片江湖中的位置如何？国产加速器中，寒武纪是重要玩家，它的思元系列（MLU）同样面向 AI 计算，架构走“MLU 指令集 + 多核 TensorCore”路线，在推理场景和其自研框架适配上有积累；燧原 GCU 则强调“更通用的 AI 计算平台”，提供类 CUDA 的编程模型和完整的 PyTorch 适配，降低用户迁移成本。而 英伟达 依然是全球生态标杆，CUDA 平台经过十余年沉淀，开发者生态和第三方库无人能及。

选型时不能只看参数表上的“峰值算力”——就像不能只比灶头数量，还要看菜谱体系（软件生态）、食材供应链（存储带宽）和厨师培训（学习成本）。国产芯片的优势在于供应安全、性价比、以及本地化技术支持，但短板往往是软件生态的成熟度。一个务实的决策角度是 能效比与性价比：

回到最初那次“超级厨房”的选择：如果你要在全国开一百家连锁店，不仅要看主厨翻锅快不快，还要看菜谱能否复制、厨师能否快速上手、食材供应链是否稳定。燧原 GCU 在国产化浪潮中的机会，正是用“通用架构 + 开放生态”去撬动英伟达的既有地盘；而对使用者而言，选型的关键从来不是单一指标，而是算力、带宽、软件、成本这四张牌的组合最优解。

PE=TFLOPSPpower\displaystyle PE = \frac{TFLOPS}{P_{power}}
能效比像“每度电能炒多少盘菜”：同样标称算力的芯片，功耗越低，机房电费越少，单机柜能部署的卡也越多。
  1. TFLOPS（峰值算力）芯片每秒能执行的浮点运算次数，单位是万亿次每秒，代表理论最快出菜速度。
    TFLOPS=浮点运算次数/1012\displaystyle TFLOPS = \text{浮点运算次数} / 10^{12}
  2. P_power（功耗）芯片满载时的电力消耗，单位瓦特。功耗不仅影响电费，还决定散热成本。
    Ppower=芯片功耗 + 散热功耗分摊\displaystyle P_{power} = \text{芯片功耗 + 散热功耗分摊}
  3. 比值决策PE 权衡了性能与能耗，在同等算力预算下，PE 更高的芯片能带来更低的总拥有成本（TCO）。
    PE=TFLOPSPpower→TCO 越低，越适合大规模部署\displaystyle PE = \frac{TFLOPS}{P_{power}} \rightarrow \text{TCO 越低，越适合大规模部署}

AI 应用场景

大模型推理加速

阶段：模型推理与部署

解决的问题：大语言模型（LLM）推理时，显存带宽和批处理吞吐是刚需。传统 GPU 推理成本高，且存在供应风险；GCU 依托大容量 HBM 和专用矩阵单元，可以在降本的同时保证低延迟生成。

具体案例：某智能客服厂商把 70B 参数的对话模型从 GPU 迁移到燧原 GCU 集群，通过算子融合和 KV Cache 优化，将单 token 生成延迟控制在 50ms 内，整体推理成本下降约 40%。

云端训练算力集群

阶段：模型训练与迭代

解决的问题：大规模分布式训练需要芯片具备高算力、高带宽和高效多卡互联。GCU 的多卡互联方案配合集合通信库，能支撑千亿参数模型的梯度同步，减少训练等待。

具体案例：一家 AI 公司使用燧原 GCU 构建 64 卡训练集群，对视觉大模型进行分布式预训练。通过流水线并行与数据并行混合策略，训练吞吐达到单卡方案的 52 倍，接近线性扩展。

垂直行业国产化替代

阶段：算力选型与适配

解决的问题：金融、政务、能源等对供应链安全要求高的行业，急需国产 AI 算力替代。GCU 的类 CUDA 接口大幅降低了存量代码迁移成本。

具体案例：某银行风控系统原使用 CUDA 编写的推理服务，借助燧原 SDK 的迁移工具，仅用两周就完成算子适配和精度对齐，成功部署在国产化服务器上，通过等保测评。

Python 演示

python27 行
"""模拟燧原GCU分块矩阵乘法的算术强度与访存量"""def matmul_flops(M, N, K):    """矩阵乘法的浮点运算次数: 乘与加各计一次"""    return 2 * M * N * K def tile_bytes(Tm, Tn, K, elem_size=4):    """一次分块计算搬运的字节数: 读A块加B块, 写回C块"""    a_bytes = Tm * K * elem_size    b_bytes = K * Tn * elem_size    c_bytes = Tm * Tn * elem_size    return a_bytes + b_bytes + c_bytes def arithmetic_intensity(Tm, Tn, K):    """计算访存比: 每搬运1字节能做多少次浮点运算"""    return matmul_flops(Tm, Tn, K) / tile_bytes(Tm, Tn, K) def main():    K = 64    print("参考: 分块沿K维固定为64")    print("分块大小    算术强度(FLOPs/Byte)")    for Tm in (16, 32, 64, 128):        for Tn in (16, 32, 64, 128):            ai = arithmetic_intensity(Tm, Tn, K)            print("%4d x %-4d  %9.1f" % (Tm, Tn, ai)) if __name__ == "__main__":    main()
目的：模拟 GCU 上分块矩阵乘法的计算访存比，直观展示分块越大、数据复用越好、算术强度越高的优化原则。
  1. def matmul_flops(M, N, K)计算矩阵乘法的浮点运算总量，对应正文中的 $2MNK$。
  2. a_bytes + b_bytes + c_bytes把一次分块计算所需的搬运字节数拆成读 A、读 B、写 C 三部分，模拟 SRAM 操作台的存取过程。
  3. return matmul_flops(Tm, Tn, K) / tile_bytes(Tm, Tn, K)核心公式：运算量除以访存量，得到算术强度。
  4. for Tm in (16, 32, 64, 128)两层循环遍历不同分块尺寸，观察分块大小对算术强度的影响。
  5. if __name__ == "__main__"标准入口，让脚本可直接运行，输出一张分块策略对比表。
  6. print("%4d x %-4d %9.1f" % (Tm, Tn, ai))格式化输出，便于直接看出趋势。

常见误区

误区GCU 名字里带“计算单元”，有人以为它和 GPU 一样，只是英伟达的国产平替，CUDA 程序改个环境变量就能跑。

正解虽然 GCU 和 GPU 都是并行加速器，但设计哲学不同。GPU 保留图形渲染电路，功能更全但能效比有折损；GCU 是面向 AI 计算的专用处理器，砍掉与张量计算无关的模块，追求极致的算力与带宽配比。软件层面，GCU 提供类 CUDA 的接口方便迁移，但不是 CUDA 指令集原生兼容。

为何常见：因为大众习惯把“AI 加速芯片”简称为“国产 GPU”，加上各家宣传口径有意模糊概念，导致混淆。

误区看到一款加速卡标称 64GB 显存，就觉得它肯定比 32GB 的卡快一倍。

正解大模型训练确实需要大显存容纳权重和中间激活值，但决定训练快慢的关键往往是带宽和计算访存比。如果数据搬不出来，再大的冷库也只是摆设。GCU 真正厉害的是用 HBM 高带宽配合大容量 L2/SRAM，把高频数据留在片上。性能要看综合指标，不能唯容量论。

为何常见：因为消费级市场“大内存=高性能”的直觉印象深入人心，服务器领域很多人也只对比容量这个唯一容易量化的数字。

误区国产芯片标称算力已经超过某些英伟达卡，于是认为“算力第一就是天下第一”。

正解峰值 TFLOPS 只是理论最大值，真实性能还要看算子库是否齐备、编译器能否生成高效指令、多卡通信是否顺畅。Amdahl 定律和 Roofline 模型告诉我们，瓶颈往往藏在访存和通信里。有时一颗标称算力更低的芯片，因为软件栈成熟，实际跑出更高的利用率。

为何常见：宣传材料总突出最亮眼的峰值指标，而将实际性能依赖的软件生态、互联效率等细节淡化，容易误导只看参数表的人。

误区有人看到国产加速器多用在推理服务器上，就断定 GCU 这类芯片架构太简单，做不了复杂的反向传播训练。

正解GCU 的矩阵计算单元天然支持前向和反向的计算模式，加上大显存和高速多卡互联，完全可以承担分布式预训练任务。之所以多数落地案例是推理，是因为推理市场更大、部署更快，而非芯片能力不行。用 GCU 做大规模训练需要更深的框架适配和算子优化，工程投入更高，但可行。

为何常见：因为公开的国产芯片案例以推理为主，训练场景的适配成本高、案例少，人们容易以偏概全。

面试题

Q1. GCU 中的字母 G 代表什么含义？

单选题 · easy

  • A.Graphics（图形）
  • B.General（通用）← 正确答案
  • C.Giant（巨大）
  • D.Global（全局）

答案：B。GCU 全称 General Computing Unit，即“通用计算单元”，强调其面向通用 AI 计算场景的设计定位。Graphics 是 GPU 的原始用途，Giant 和 Global 是干扰项，与燧原的官方定义无关。

Q2. 燧原 GCU 与英伟达 GPU 最本质的区别是？

单选题 · easy

  • A.GPU 不能做 AI 计算
  • B.GCU 能做图形渲染
  • C.GCU 是 AI 专用加速器← 正确答案
  • D.两者没有任何区别

答案：C。GCU 从设计之初就聚焦 AI 张量计算，砍掉了图形渲染等非 AI 电路；而 GPU 起源于图形渲染，后来才扩展到通用计算。GPU 当然能做 AI，GCU 也保留了基础并行能力，但本质区别是专用与通用的定位差异。

Q3. 燧原 GCU 异构核心中，负责循环和地址计算的是？

单选题 · mid

  • A.矩阵计算单元
  • B.向量计算单元
  • C.标量控制单元← 正确答案
  • D.HBM 显存控制器

答案：C。标量控制单元负责流程控制，包括循环分支、地址计算和任务调度，相当于厨房里的传菜指挥；矩阵单元负责大吞吐张量运算，向量单元负责逐元素操作，HBM 控制器管显存读写，均不符合题意。

Q4. 算术强度（计算访存比）的定义是？

单选题 · mid

  • A.显存容量除以核心数量
  • B.浮点运算次数除以访存字节数← 正确答案
  • C.芯片功耗除以峰值算力
  • D.网络带宽乘以延迟

答案：B。算术强度 = FLOPs / Bytes，衡量每搬运 1 字节数据能做多少次浮点运算。它决定了任务是算力瓶颈还是带宽瓶颈，是 Roofline 分析和分块调优的核心指标。其余选项分别涉及容量、功耗和网络，与本概念无关。

Q5. 下列哪一层存储对应“厨师手边的操作台”？

单选题 · mid

  • A.HBM 高带宽显存
  • B.固态硬盘 SSD
  • C.片上 SRAM← 正确答案
  • D.主存 DRAM

答案：C。片上 SRAM 距离计算核心最近，容量小但速度极快，就像操作台上随手可取的调料；HBM 是大容量冷库，SSD 是仓库外的货架，DRAM 是主存，均比 SRAM 慢且离核心更远。

Q6. 算子融合优化最重要的收益是？

单选题 · mid

  • A.增加算子的数量
  • B.减少启动开销和中间搬运← 正确答案
  • C.降低模型参数的精度
  • D.增大显存的物理容量

答案：B。算子融合把多个小算子合并成一个大内核，既减少了 CPU 下发内核的启动次数（T_launch），又让中间结果留在片上缓存而无需写回显存（Q_data 下降），直击访存瓶颈。它不改变计算量，也不改变精度和容量。

Q7. 某任务在 GCU 上计算量 200 GFLOPS，访存量 50 GB，算术强度为？

单选题 · hard

  • A.4 FLOPs/Byte← 正确答案
  • B.0.25 FLOPs/Byte
  • C.10000 FLOPs/Byte
  • D.250 FLOPs/Byte

答案：A。算术强度 = FLOPs / Bytes = 200 × 10⁹ / 50 × 10⁹ = 4 FLOPs/Byte。注意单位统一：200 GFLOPs 即 200×10⁹ 次运算，50 GB 即 50×10⁹ 字节，相除得到 4。选项 B 是倒数算反了，C 和 D 的数量级错误。

Q8. 下列哪些属于提升 GCU 利用率的优化策略？

多选题 · mid

  • A.算子融合← 正确答案
  • B.内存复用← 正确答案
  • C.增大单次访存的数据量
  • D.合理配置并行度← 正确答案

答案：ABD。算子融合减少启动开销，内存复用降低有效搬运算，合理配置并行度让核心不空等，三者都是标准优化手段。增大单次访存量会抬高搬运总量，反而恶化带宽瓶颈，属于错误操作。

Q9. 关于燧原 GCU 软件栈，下列说法正确的有？

多选题 · hard

  • A.支持 PyTorch 等主流框架← 正确答案
  • B.提供类 CUDA 的编程接口← 正确答案
  • C.与 CUDA 完全二进制兼容
  • D.编译器将计算图翻译为机器指令← 正确答案

答案：ABD。GCU 软件栈确实通过框架适配层支持 PyTorch、TensorFlow 等，并提供类 CUDA 接口以便迁移。编译器负责把高层算子翻译为底层指令。但它与 CUDA 指令集不同，不可能直接运行 CUDA 编译产物，故 C 错误。

Q10. 影响 GCU 实际性能释放的主要因素包括？

多选题 · hard

  • A.计算访存比配置← 正确答案
  • B.多卡互联带宽← 正确答案
  • C.软件栈的成熟度← 正确答案
  • D.芯片封装的外观尺寸

答案：ABC。计算访存比决定瓶颈类型，多卡互联带宽决定分布式扩展上限，软件栈成熟度决定算子能否高效执行——三者都是实际性能的关键变量。封装尺寸影响的是物理兼容性和散热设计，不直接决定计算性能。