想象你要为一场万人宴会准备饭菜。传统做法是：请几千个厨师，每人一间小厨房，但食材统一堆在几公里外的中央仓库。每做一道菜，厨师都要派助手骑车去仓库取肉、取菜，路上还会堵车。结果大厨们经常空着锅等食材——这就是AI训练中的“内存墙”。而Cerebras CS-3的思路，是把厨房改造成一座“超级中央厨房”：一整块圆桌大的硅晶圆就是操作台，90万名厨师（AI核心）围桌而立，桌中央就是44GB的巨型冷库，一伸手就拿到食材。再加上“有经验的厨师会跳过多余的调料”（稀疏内核），这场万人宴终于能高效开席了。本文就用这个“超级厨房”的比喻，带你拆解CS-3的晶圆级集成、片上存储和稀疏计算，看看它是如何撼动GPU在大模型训练中的霸主地位。

岗位关联

理解Cerebras CS-3的架构思想，能帮你跳出“堆GPU卡”的惯性思维，从系统层面理解AI算力瓶颈的解法，是AI Infra与芯片方向从业者的必修课。

目录
  1. 可视化演示
  2. 内存墙瓶颈
  3. 晶圆级集成
  4. 片上存储优势
  5. 稀疏计算内核
  6. 大模型训练
  7. 部署成本
  8. 未来演进
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示WSE-3晶圆级核心阵列、片上SRAM消除内存墙对比与Weight Streaming权重流式训练架构，支持模式切换。

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

WSE-3晶圆级核心阵列 90万SLAC核心以数据流方式工作 径向激活波模拟核心并行计算 冗余核心绕过制造缺陷保证良率 WSE-3: 900K cores, 44GB SRAM, 5nm 晶圆级集成消除跨芯片互连瓶颈

内存墙瓶颈

在万人宴的厨房里，最怕的不是厨师手慢，而是“肉还在路上”。传统GPU训练大模型时，GPU核心就像小厨师，真正能干的活儿不到一半时间——另一半时间全在等参数从外面的“中央仓库”（HBM或DRAM）搬进来。一次模型更新要读取几十GB的权重，而芯片到外部存储的“马路”就那么几条，堵得水泄不通。这就是AI圈常说的“内存墙”（Memory Wall）：算力跑得再快，也被访存拖住后腿。

内存墙的本质，是“计算速度”和“数据搬运速度”之间差了上千倍。GPU每秒能做几千万亿次运算，但从外部内存读一个浮点数要几百个时钟周期。于是公式告诉我们，需要的访存带宽取决于三个因素：时钟频率、核心数量、每次读取的字节数。

把这笔账算下来，哪怕只有90万个核心中的一小撮在跑，带宽需求也是天文数字。要拆掉这堵墙，不能靠多修几条路，而要把仓库直接搬到厨师手边——这正是Cerebras的解题方向。

Breq=fclock×Ncore×Wweight\displaystyle B_{\text{req}} = f_{\text{clock}} \times N_{\text{core}} \times W_{\text{weight}}
通俗地说：每秒要搬多少食材 = 每个厨师一分钟炒几道菜 × 厨师人数 × 每道菜要拿多少斤肉。
  1. 时钟频率$f_{\text{clock}}$ 表示芯片每秒钟跳几次“节拍”，节拍越快，单位时间内发起的取数请求越多。
    fclock=1 GHz=109 次/秒\displaystyle f_{\text{clock}} = 1\ \text{GHz} = 10^9\ \text{次/秒}
  2. 核心数量$N_{\text{core}}$ 是同时干活的AI核心总数。核心越多，同时伸手取食材的手就越多，总需求量线性上升。
    Ncore=9×105\displaystyle N_{\text{core}} = 9 \times 10^5
  3. 权重字节数$W_{\text{weight}}$ 是每个权重（食材）用几个字节表示。精度越高字节越多，搬运量越大。
    Wweight=4 Bytes (FP32)\displaystyle W_{\text{weight}} = 4\ \text{Bytes}\ (\text{FP32})

晶圆级集成

Cerebras的思路，是把“小厨房+远仓库”彻底推翻，直接建造一座“圆桌厨房”：一整块直径300毫米的硅晶圆，不做切割，直接当作一颗芯片来用。传统芯片是从晶圆上切出一个个小方块，Cerebras却反其道而行之——让整张晶圆就是芯片，这就是“晶圆级集成”（Wafer-Scale Integration）。WSE-3在这张圆桌上摆下了90万个AI核心，还盖了一座44GB的片上SRAM冷库（SRAM是速度极快的静态随机存取存储器）。

晶圆级芯片的面积，取决于晶圆本身的几何尺寸。300毫米直径的圆，面积约为706平方厘米，是普通GPU芯片（如A100约826平方毫米）的85倍。芯片面积大，就能塞进更多核心和更近的存储。

晶圆级集成并非没有代价。一张晶圆上只要有一个制造缺陷，就会报废整颗芯片。Cerebras的绝招是“容错设计”：芯片里预留了大量冗余核心和可绕行的互联，出厂后通过测试屏蔽坏点，就像宴会桌破了几个角，铺上桌布照样能用。这突破了良率魔咒，也让“一桌炒万人宴”成为可能。

Awafer=πr2=π×(150 mm)2≈706 cm2\displaystyle A_{\text{wafer}} = \pi r^2 = \pi \times (150\ \text{mm})^2 \approx 706\ \text{cm}^2
通俗地说：一块圆形餐桌的面积 = 3.14 × 半径的平方。半径150毫米，桌面就是一张铺满的宴会桌。
  1. 圆周率$\pi$ 是圆的面积系数，约3.14159，它是圆的周长与直径之比，也出现在面积公式中。
    π≈3.14159\displaystyle \pi \approx 3.14159
  2. 半径平方$r^2$ 表示半径自乘。半径从75毫米翻倍到150毫米，面积会扩大4倍，所以“整张晶圆”的餐桌面积远比想象中大。
    r=150 mm,r2=22500 mm2\displaystyle r = 150\ \text{mm},\quad r^2 = 22500\ \text{mm}^2
  3. 面积结果算出的706平方厘米是“桌面”总面积，核心和存储都在这张桌上就近布置。
    706 cm2≈85×8.26 cm2\displaystyle 706\ \text{cm}^2 \approx 85 \times 8.26\ \text{cm}^2

片上存储优势

有了这张巨型圆桌，最大的变化不是面积，而是“距离”。之前厨师取菜要骑车去几公里外的仓库，现在冷库就在桌子中央，厨师一伸手就能拿到食材。WSE-3把44GB SRAM直接做在晶圆上，紧贴着90万个核心，这就是“片上存储”（On-Chip SRAM）。模型权重不再需要从外部HBM一趟趟搬运，而是像囤好食材一样，全部驻留在手边。

访问数据的时间，本质上就是“距离 ÷ 速度”。距离从几十毫米的板级走线，缩短到几百微米的片上互连，时间自然下降了几个数量级。

近水楼台先得月。权重驻留片上，还带来两个隐藏好处：一是省电，因为不再需要驱动长距离信号和高功耗的HBM接口；二是省沟通，训练时梯度同步不用跨卡传递，90万核心就像一个团队在内部交头接耳，而不是隔着电话线喊话。这为后面的大模型训练扫清了最大障碍。

Taccess=Lv\displaystyle T_{\text{access}} = \frac{L}{v}
通俗地说：拿一袋盐的时间 = 盐放得有多远 ÷ 你跑得有多快。把盐从楼下搬到灶台边，炒菜自然快。
  1. 距离$L$ 是核心到存储的物理距离。GPU时代要走芯片外的电路，CS-3时代只在晶圆内部走几步。
    LGPU≈10 cm,LCS-3≈0.1 cm\displaystyle L_{\text{GPU}} \approx 10\ \text{cm},\quad L_{\text{CS-3}} \approx 0.1\ \text{cm}
  2. 传播速度$v$ 是电信号在导线中的速度，接近光速但受介质影响，约每秒20万公里。
    v≈2×1010 cm/s\displaystyle v \approx 2 \times 10^{10}\ \text{cm/s}
  3. 访问时间把距离除以速度，CS-3的片上访问时间比GPU访问外部存储快约两个数量级。
    TCS-3≈0.12×1010=5 ps\displaystyle T_{\text{CS-3}} \approx \frac{0.1}{2 \times 10^{10}} = 5\ \text{ps}

稀疏计算内核

宴会做到一半，有经验的厨师会发现：有的菜谱里写着“八角三颗”，但锅里那锅肉根本用不上八角——他们会直接跳过这道工序。AI模型训练里也有大量这样的“用不上的调料”：权重矩阵中接近80%~90%的数值是零或者小到可以忽略。传统GPU不管三七二十一，每个权重都做一次乘加；CS-3的“稀疏内核”（Sparse Engine）则像那个有经验的厨师，遇到零值就跳过，不做无效计算。

稀疏加速的数学很简单：原本要算N次乘法，其中N_zero次是零值，跳过之后只需要算剩下的非零部分。

需要强调的是，稀疏内核的加速不是免费的：硬件需要能快速识别零值并跳过，CS-3在数据通路里加入了专门的稀疏检测逻辑，让“跳菜”这个动作本身几乎没有开销。而当稀疏度高达95%时，理论加速比能达到20倍，这才是CS-3敢叫板GPU的底气。

S=NN−Nzero=11−s\displaystyle S = \frac{N}{N - N_{\text{zero}}} = \frac{1}{1 - s}
通俗地说：稀疏度80%时，做100道菜只有20道需要真动手，速度提升就是100÷20=5倍。
  1. 总计算量$N$ 表示矩阵乘法中所有乘加运算的次数，也就是所有“待做的菜”。
    N=M×K\displaystyle N = M \times K
  2. 零值数量$N_{\text{zero}}$ 是权重中被剪枝为零的项，这类运算结果为0，算与不算不影响结果。
    Nzero=s×N\displaystyle N_{\text{zero}} = s \times N
  3. 稀疏度$s$ 是零值占比。当 $s=0.9$ 时，只有10%的非零计算需要执行。
    s=NzeroN=0.9\displaystyle s = \frac{N_{\text{zero}}}{N} = 0.9
  4. 加速比$S$ 是理论加速倍数，1除以非零比例。稀疏度越高，加速越夸张。
    S=11−0.9=10\displaystyle S = \frac{1}{1 - 0.9} = 10

大模型训练

把前面几件武器组装起来，就得到了CS-3系统：一台机箱里装着整套“超级厨房”。训练千亿参数大模型时，GPU集群要把参数分到几千张卡上，每算一步都要全球同步一次梯度，网络通信慢如传话游戏；而CS-3因为44GB权重全在片上，90万核心可以像一个人一样协同计算，不需要频繁的跨卡通信，训练速度大幅提升，而且扩展性接近线性——再加一台CS-3，吞吐量几乎翻倍。

把这三件武器组合起来，就能估算训练耗时：参数越多越慢，带宽越足越快，稀疏跳过越多越省。训练耗时大致可以写成这样一个比例关系：

CS-3并不是要完全取代GPU，而是在特定的超大规模预训练场景下提供了另一种选择：当模型大到GPU集群通信开销失控时，CS-3“一个人就是一支军队”的架构能大大降低同步成本。它更适合那些“参数多、通信重、稀疏度高”的巨头模型，比如超长上下文、多模态大模型。

Ttrain∝PBeff×1Ssparse\displaystyle T_{\text{train}} \propto \frac{P}{B_{\text{eff}}} \times \frac{1}{S_{\text{sparse}}}
通俗地说：训练一桌满汉全席的时间 = 菜品总数（参数P） ÷ 原料搬运效率（有效带宽） ÷ 跳菜技巧（稀疏加速）。
  1. 参数总量$P$ 是模型参数量，参数越多，需要计算的乘加越多，时间越长。
    P=1.8×1011 (GPT-3规模)\displaystyle P = 1.8 \times 10^{11}\ (\text{GPT-3规模})
  2. 有效带宽$B_{\text{eff}}$ 是训练系统实际能持续供给数据的带宽。CS-3的片上带宽比GPU外部带宽高出一个量级。
    Beff=Won-chipTaccess\displaystyle B_{\text{eff}} = \frac{W_{\text{on-chip}}}{T_{\text{access}}}
  3. 稀疏加速$S_{\text{sparse}}$ 是稀疏内核带来的加速倍数，它直接缩短计算环节的时间。
    Ssparse=11−s\displaystyle S_{\text{sparse}} = \frac{1}{1 - s}

部署成本

再完美的厨房，也要看账本。CS-3这种晶圆级系统的采购成本相当高，一台设备的售价远高于一台8卡GPU服务器；同时90万核心同时运转，功耗和散热也是硬骨头，需要专门的液冷方案；软件生态更是绕不过去的坎——PyTorch等框架对晶圆级芯片的支持仍在成熟中，迁移现有模型需要重写部分算子。这些“建厨房的装修费”必须纳入考量。

这笔账不能只看单台机器的价格，还要把电费、液冷维护、工程师适配框架的时间都算进去。做生意要算投资回报率：省下的训练时间能否覆盖多花的钱。

所以，CS-3适合的是“预算充足、追求极致训练速度、跑超大模型”的头部玩家，而不是刚起步的小团队。真正的决策不是“哪个芯片更强”，而是“哪个方案的总账更划算”。

ROI=G加速收益C采购+C运营\displaystyle \text{ROI} = \frac{G_{\text{加速收益}}}{C_{\text{采购}} + C_{\text{运营}}}
通俗地说：值不值 = 提前开宴赚到的钱 ÷ （装修费 + 水电费）。
  1. 加速收益$G_{\text{加速收益}}$ 是训练时间缩短带来的成本节省，例如从30天降到7天，省下的23天算力和人力成本。
    G=ΔT×Ccluster/天\displaystyle G = \Delta T \times C_{\text{cluster/天}}
  2. 采购成本$C_{\text{采购}}$ 是购买CS-3系统的费用，包含晶圆级芯片、主板、机箱和液冷。
    C采购≫C8×GPU\displaystyle C_{\text{采购}} \gg C_{\text{8×GPU}}
  3. 运营成本$C_{\text{运营}}$ 是电费、液冷维护、软件适配工程师的长期开销。
    C运营=P功耗×t×p电价\displaystyle C_{\text{运营}} = P_{\text{功耗}} \times t \times p_{\text{电价}}

未来演进

宴会还在继续，厨房也在进化。Cerebras的晶圆级路线揭示了一个趋势：与其在芯片外面修路，不如把存储和计算焊在同一张桌子上。未来，更进一步的方向是“存算一体”——连“取食材”这个动作都省掉，直接在冷库里炒菜；或者用“光互连”代替电信号传输，让远距离通信再提速。行业影响也随之扩大：不只是AI训练，科学计算、基因测序、金融风控都可能用上晶圆级算力。

从工程视角看，一台芯片的总产能不是由单一因素决定的，而是能耗预算和面积密度共同作用的结果。性能演进可以看作两个因子的乘积：

从90万核心的WSE-3开始，晶圆级芯片的方向已经清晰：不是把GPU做大，而是从物理上重构“算力找数据”的方式。对AI从业者来说，理解这场厨房革命，就是在为下一轮算力竞赛提前占好了座位。

Epeak∝Ppower×ρdensity\displaystyle E_{\text{peak}} \propto P_{\text{power}} \times \rho_{\text{density}}
通俗地说：厨房的总产能 = 灶台数量 × 每个灶台的出菜速度。
  1. 功耗预算$P_{\text{power}}$ 是芯片能承受的功耗上限，液冷等技术解锁更高的预算。
    Ppower=Vdd×Ichip\displaystyle P_{\text{power}} = V_{\text{dd}} \times I_{\text{chip}}
  2. 面密度$\rho_{\text{density}}$ 是单位面积内的核心或存储密度，工艺制程越先进密度越高。
    ρ=NcoreAwafer\displaystyle \rho = \frac{N_{\text{core}}}{A_{\text{wafer}}}

AI 应用场景

千亿参数大模型预训练

阶段：模型训练与基础设施选型

解决的问题：传统GPU集群训练千亿参数模型时，梯度同步和参数分片带来的通信开销可能占训练时间的50%以上，算力被白白浪费。CS-3把模型权重全部驻留在44GB片上SRAM中，相当于把所有食材都搬进厨房冷库，厨师不用再去外面取货；90万核心共享近核存储，梯度更新不需要跨卡互传，通信开销几乎消失，训练速度大幅提升。

具体案例：某AI公司需要训练一个1.8万亿参数的语言模型，原计划使用2048张GPU训练90天。改用CS-3集群后，权重无需频繁搬运，训练周期缩短到30天左右，模型收敛更快，还省下大量电力成本。

稀疏剪枝模型的微调与推理

阶段：模型压缩与推理优化

解决的问题：大模型剪枝后权重矩阵稀疏度常达80%~90%，但GPU对稀疏矩阵的加速支持有限，依然按稠密矩阵运算。CS-3的稀疏内核能在硬件层面跳过零值乘加，就像熟手厨师自动跳过用不上的调料，让剪枝后的模型真正“瘦身”，推理延迟显著下降。

具体案例：一家AI客服公司想把120亿参数的对话模型压缩后部署到云端，剪枝后稀疏度为85%。在CS-3上微调和推理，有效计算量缩减到原来的15%，单次推理耗时比同规模GPU方案降低约5倍。

Python 演示

python50 行
import random class SparseEngine:    """模拟Cerebras CS-3稀疏内核的一次前向计算"""     def __init__(self, size=20000, sparsity=0.8):        self.size = size        self.sparsity = sparsity        # 80% 的权重被剪枝为零,模拟稀疏大模型        rng = random.Random(42)        self.weights = [            0.0 if rng.random() < self.sparsity else rng.random()            for _ in range(self.size)        ]     def is_zero(self, value):        return value == 0.0     def dense_forward(self, inputs):        # 传统GPU:所有权重一视同仁,逐个乘加        total = 0.0        macs = 0        for i in range(self.size):            total += self.weights[i] * inputs[i]            macs += 1        return total, macs     def sparse_forward(self, inputs):        # 稀疏内核:遇到零值直接跳过,省掉无效乘加        total = 0.0        macs = 0        for i in range(self.size):            w = self.weights[i]            if self.is_zero(w):                continue            total += w * inputs[i]            macs += 1        return total, macs  if __name__ == "__main__":    engine = SparseEngine(size=20000, sparsity=0.8)    inputs = [1.0] * engine.size    dense_out, dense_macs = engine.dense_forward(inputs)    sparse_out, sparse_macs = engine.sparse_forward(inputs)    speedup = dense_macs / sparse_macs    print("dense MACs:", dense_macs)    print("sparse MACs:", sparse_macs)    print("theoretical speedup: {:.2f}x".format(speedup))    print("output equal:", abs(dense_out - sparse_out) < 1e-9)
目的：用简单的向量点积模拟GPU全量计算与CS-3稀疏内核跳过零值的差异，输出理论加速比。
  1. self.weights = [0.0 if rng.random() < self.sparsity else rng.random() for _ in range(self.size)]初始化时按稀疏度生成权重，80%的权重为零，模拟剪枝后的模型。
  2. self.is_zero(value)判断权重是否为零，对应CS-3硬件中的稀疏检测逻辑。
  3. def dense_forward(self, inputs)模拟传统GPU：每个权重都执行一次乘加，零值也白白消耗算力。
  4. total += self.weights[i] * inputs[i]全量乘加是“内存墙”之外的另一大浪费来源。
  5. if self.is_zero(w): continue稀疏内核的灵魂：零权重直接跳过，不碰乘加器。
  6. speedup = dense_macs / sparse_macs用有效乘加次数之比估算理论加速比。

常见误区

误区WSE-3有90万个AI核心，是不是相当于90万张GPU卡堆在一起，性能是GPU的几万倍？

正解90万指的是大量简单、专用的AI计算单元，不是完整的GPU。GPU芯片拥有复杂的图形与通用计算管线、高主频和大缓存，而WSE-3核心更小、更专一，主打低功耗并行乘加。好比90万名只会切菜的帮厨，和90万名全能大厨不能直接画等号。Cerebras的卖点不是“核心多”，而是“核心离存储近+稀疏跳过”的组合拳。

为何常见：厂商宣传中“核心数”最抓眼球，外行很容易拿核心数直接对比GPU，忽略了核心质量和架构差异。

误区GPT-3有1750亿参数，44GB连模型参数都装不下，怎么可能解决内存墙？

正解训练不是把整个模型一次性塞进芯片，而是按层分块计算。44GB足以驻留一个大型模型的关键权重层或优化器状态，关键是把“频繁访问的热数据”放到片上，避免每次迭代都去外部取数。就像厨房冷库存不了全城所有人一周的菜，但能存下今晚宴席要用的食材，这就够了。

为何常见：大家习惯把“显存大小”和“模型大小”直接比较，忽略了训练是流水线式按层执行的，驻留粒度是层而非整个模型。

误区只要权重里有零，CS-3就能直接跳过，加速比就是1/(1-稀疏度)，完全不吃亏。

正解稀疏度决定了计算环节的理论上限，但实际训练中还有访存、同步、非稀疏层等不可跳过的部分。阿姆达尔定律告诉我们，整体加速受不可并行部分限制。此外，跳过零值需要硬件能高效识别稀疏结构，结构化稀疏比随机稀疏更容易受益，剪枝不当还会损伤模型精度。加速是有条件的，不是白捡的便宜。

为何常见：大家容易只盯着“跳过零值”这一个环节，忽略了系统中还有很多环节无法跳过。

误区一整块晶圆上只要有一个缺陷就整片报废，Cerebras芯片应该只能手工打造，没法大规模部署。

正解Cerebras通过冗余设计解决良率问题：WSE-3上设计了大量备用核心和可重构互连，出厂时测试每个计算单元，坏掉的单元被屏蔽，数据通路自动绕行。就像宴会桌上有个洞，铺上桌布把洞盖住，其他位置照常用。所以CS-3可以量产，只是成本依然高昂。

为何常见：传统芯片制造逻辑是“切小片保良率”，晶圆级反其道而行之，大家很难想象“整片用”也能解决缺陷问题。

面试题

Q1. WSE-3在一整块晶圆上集成了大约多少个AI核心？

单选题 · easy

  • A.9万个
  • B.90万个← 正确答案
  • C.900万个
  • D.9000万个

答案：B。WSE-3集成约90万个AI核心，这是晶圆级集成的标志性数字。9万个太小，900万和9000万则过度夸大。可以理解为宴会桌旁站着90万名厨师，而不是9万或900万。

Q2. 44GB片上SRAM首要解决的是什么问题？

单选题 · easy

  • A.内存墙瓶颈← 正确答案
  • B.芯片散热
  • C.制造良率
  • D.软件生态

答案：A。把大容量SRAM放在片上，目的是让权重靠近核心，减少对外部存储的访问，直接对付“内存墙”。散热、良率、生态是晶圆级芯片的其他挑战，但不是这片存储的主要目标。

Q3. 某权重矩阵稀疏度为90%，稀疏内核理想化的计算加速上限是？

单选题 · mid

  • A.约1.11倍
  • B.约9倍
  • C.约10倍← 正确答案
  • D.约100倍

答案：C。加速比 = 1 / (1 - 稀疏度) = 1 / (1 - 0.9) = 10倍。对应含义：做100份菜只有10份需要真动手，总时间缩到十分之一。注意这是只考虑计算环节的理想上限，实际还会受访存和同步限制。

Q4. 相比传统GPU集群，CS-3在大模型训练中的优势包括？

多选题 · mid

  • A.权重驻留片上← 正确答案
  • B.消除大部分跨卡通信← 正确答案
  • C.支持任意精度
  • D.降低内存带宽压力← 正确答案

答案：ABD。CS-3把权重放在44GB片上SRAM，避免了频繁外部访存，梯度同步不需要大规模跨卡通信，因此带宽压力大减。但它并不支持“任意精度”，精度仍由硬件设计决定。所以选A、B、D。

Q5. 晶圆级芯片面对制造缺陷，Cerebras采取的应对策略是？

单选题 · mid

  • A.冗余容错，屏蔽坏核← 正确答案
  • B.提高时钟频率
  • C.缩小晶圆面积
  • D.放弃缓存

答案：A。WSE-3通过冗余核心和可重构互连，在出厂测试中屏蔽坏点，让整张晶圆仍可工作，就像桌布盖住桌面的破洞。提高频率、缩小面积、放弃缓存都不是解决良率的办法。

Q6. 片上SRAM访问外部HBM时，访问时间主要由什么决定？

单选题 · mid

  • A.距离除以传播速度← 正确答案
  • B.频率乘以电压
  • C.核心数除以功耗
  • D.容量乘以带宽

答案：A。访问时间 = 距离 / 速度。CS-3把存储放到核心旁边，距离缩短几个数量级，访问时间随之骤降。频率、电压、容量都不直接决定单次访存的物理延迟。

Q7. Cerebras CS-3部署成本考量通常包含哪些方面？

多选题 · hard

  • A.整机采购价格高← 正确答案
  • B.功耗与液冷散热← 正确答案
  • C.软件生态适配成本← 正确答案
  • D.开源社区维护费

答案：ABC。采购成本高、功耗散热压力大、PyTorch等框架适配需要额外工程投入，这三点是CS-3落地的核心成本。开源社区维护是宏观生态问题，不属于单台CS-3部署的直接成本项。

Q8. 下列哪项最符合“稀疏计算”的含义？

单选题 · easy

  • A.跳过零值运算← 正确答案
  • B.减少芯片面积
  • C.降低时钟频率
  • D.增大存储容量

答案：A。稀疏计算的核心是识别并跳过零值对应的乘加运算，让算力集中在有效数据上。减少面积、降低频率、增大容量都与稀疏计算无关。

Q9. 晶圆级芯片未来可能的发展方向包括？

多选题 · hard

  • A.存算一体技术← 正确答案
  • B.光互连提速← 正确答案
  • C.无限增加面积
  • D.行业广泛渗透← 正确答案

答案：ABD。存算一体直接在存储中计算、光互连用光代替电信号提速，都是晶圆级之后的方向；行业影响扩大也是趋势。芯片面积受限于晶圆物理尺寸和散热，不可能无限增大，因此C不选。

Q10. 某训练循环中，计算耗时占20%，访存耗时占80%。若稀疏内核能让计算环节提速5倍，理论总加速比约为？

单选题 · extreme

  • A.约1.19倍← 正确答案
  • B.约1.25倍
  • C.约2.50倍
  • D.约5.00倍

答案：A。阿姆达尔定律：总加速比 = 1 / [(1 - 0.2) + 0.2 / 5] = 1 / (0.8 + 0.04) ≈ 1.19倍。因为80%时间花在访存上且无法跳过，所以整体提升有限。这提醒我们，稀疏计算必须和消除内存墙配合才能发挥威力。