想象你是城东“老王芯粒披萨店”的店主。这天，一家 AI 大公司下了张订单：要一张直径比脸盆还大的“AI 豪华披萨”。问题来了——面团越大，越容易在某个角落冒出焦斑。巴掌大的饼，一尘不染很容易；桌子大的饼，几乎总有一两块焦痕。更要命的是，顾客要求整张饼必须完美无瑕，于是大披萨经常整张报废，成本高得吓人。 老王琢磨出一个妙招：把大披萨切成若干小块，每块独立烤制。焦斑只毁掉一小块，其他块照常出货。接着他又发现，顶级馅料用贵面粉、普通配料用大路货，整单成本反而更优。遇到重要宴席，他还会多烤两块备用，哪块烤坏了立刻换上——客人全程蒙在鼓里。这就是 Chiplet 芯粒组合设计的故事：把大芯片拆成小芯粒，用良率模型、混合工艺、冗余策略和分割优化，把“烤焦的成本”降到最低。 本文用“披萨店”的比喻贯穿始终，拆解芯粒组合设计与良率优化的全部关键概念：指数良率模型、拆分收益、异构工艺集成、缺陷容忍、冗余芯粒以及最优分割方案。你会发现，芯片架构师的工作，本质上和一位精明的披萨店主没什么两样。

岗位关联

掌握芯粒良率建模与分割优化方法，是设计经济可行 Chiplet 架构的核心能力，也是先进封装时代芯片架构师、硬件成本工程师的必备技能。

目录
  1. 可视化演示
  2. 良率基础模型
  3. 芯片拆分收益
  4. 混合工艺节点
  5. 缺陷容忍设计
  6. 冗余芯粒策略
  7. 分割优化方案
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

芯粒组合与良率优化通过将大芯片拆分为小芯粒来提高制造良率，同时通过混合不同工艺节点的芯粒来优化整体成本。文章建... 切换模式查看不同维度。

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

良率模型与面：核心原理 动态展示关键流程与数据流动 交互控件调节参数实时渲染 f(x) = transform(x) 核心概念的可视化呈现

良率基础模型

老王发现，披萨烤坏的根本原因，是面团里总有看不见的“焦斑隐患”——气泡、杂质、受热不均。他统计了每张饼上出现焦斑的平均数量：一张饼面积越大，踩中焦斑的概率就越高。芯片制造里，这个“焦斑隐患”叫缺陷密度（D），单位面积上平均出现的致命缺陷数；而“饼的面积”就是芯片有效面积（A）。

假设缺陷在晶圆上随机、均匀地出现——这正是泊松分布描述的随机事件：给定面积 A 上平均出现 λ=AD 个缺陷，那么“一个缺陷都没有”的概率就是 e⁻λ。芯片良率（Yield）就是“整张饼完好无损”的概率：

这个公式是老王的“烤炉经验公式”：想提高整张披萨的完好率，要么降低缺陷密度（升级烤炉），要么缩小单张饼的面积（切块）。前者是晶圆厂的事，后者正是 Chiplet 的起点。

Y=e−A×D\displaystyle Y = e^{-A \times D}
良率随芯片面积指数衰减：面积翻倍，良率不是减半，而是按 e 的指数暴跌。
  1. 缺陷密度 D单位面积（cm²）上的平均致命缺陷数，是晶圆厂工艺水平的直接体现。
    D=NdefectsAwafer\displaystyle D = \frac{N_{\text{defects}}}{A_{\text{wafer}}}
  2. 有效面积 A单颗芯片实际占用的硅片面积，单位 cm²。
    A=AwaferNchips\displaystyle A = \frac{A_{\text{wafer}}}{N_{\text{chips}}}
  3. 期望缺陷数 λ面积乘以缺陷密度，得到该芯片上平均会出现的缺陷个数。
    λ=A×D\displaystyle \lambda = A \times D
  4. 泊松零缺陷概率在 λ 个期望缺陷下，恰好出现 0 个缺陷的概率就是指数函数。
    Y=P(0)=e−λ=e−A×D\displaystyle Y = P(0) = e^{-\lambda} = e^{-A \times D}

芯片拆分收益

既然大饼容易糊，老王决定把一张“AI 大披萨”切成 N 块小饼，每块独立烤制。设总硅面积 A 不变，切成的每颗芯粒面积为 A/N，单颗芯粒良率就是 Y_c = e^{-(A/N)·D}。

小饼烤糊的概率自然低得多。但老王很快发现一个反直觉的事实：如果把“整份订单全部完好”定义为所有 N 块小饼都完美，那这个概率和原来一整张大饼完好的概率一模一样：

那么拆分的收益到底在哪？答案是独立筛选与容错复用：大饼糊了整张报废，小饼糊了只扔那 1/N。刚才的可视化里，单片良率约 37%，而 4 颗芯粒的平均可用面积接近 69%——同样一炉硅片，能卖出去的“好饼”多了近一倍。这才是拆分真正的价值，也为后文的冗余策略埋下伏笔。

Yall=(e−A×D/N)N=e−A×D\displaystyle Y_{\text{all}} = \left(e^{-A \times D / N}\right)^{N} = e^{-A \times D}
拆分本身并不改变“所有部分全部完好”的概率——蛋糕没有变大，缺陷总数没变。
  1. 单芯粒良率面积缩小 N 倍后，单颗芯粒的期望缺陷数变为 AD/N。
    Ychiplet=e−A×D/N\displaystyle Y_{\text{chiplet}} = e^{-A \times D / N}
  2. N 颗全部完好每颗芯粒独立，联合概率为各颗良率的乘积。
    Yall=(e−AD/N)N\displaystyle Y_{\text{all}} = \left(e^{-A D / N}\right)^N
  3. 指数合并N 次方与分母 N 约掉，回到与单片完全相同的表达式。
    Yall=e−AD\displaystyle Y_{\text{all}} = e^{-A D}

混合工艺节点

老王接着算账：披萨的全部配料都用进口奶酪，当然好吃，但太贵。合理的做法是——松露和火腿用顶级食材（先进工艺），饼底和普通芝士用大众货（成熟工艺），反正咬下去没人分得清饼底是哪家面粉。Chiplet 的异构集成正是这个思路：计算芯粒需要极致晶体管密度，用 3nm/5nm 先进节点；IO 芯粒、模拟芯粒、电源管理芯粒对密度不敏感，用 28nm/14nm 成熟节点，成本只有先进节点的零头。

系统级成本模型变成对每颗芯粒“分别定价再求和”：

这样，计算芯粒用先进工艺保证性能，IO 芯粒用成熟工艺压低成本，整张“披萨”的平均单价大幅下降。AMD 的 EPYC 服务器芯片正是这么做的——计算芯粒用最先进节点，IO Die 用成熟节点，一举两得。

Ctotal=∑i=1NCdie(i)Yi+Cpkg\displaystyle C_{\text{total}} = \sum_{i=1}^{N} \frac{C_{\text{die}}(i)}{Y_i} + C_{\text{pkg}}
每颗芯粒的制造成本除以其良率，才是“有效摊薄”后的真实成本；最后加上封装与测试成本。
  1. 单芯粒制造成本C_die(i) 是第 i 颗芯粒在晶圆上的硅成本（面积占比 × 晶圆价格）。
    Cdie(i)=Cwafer×AiAwafer\displaystyle C_{\text{die}}(i) = C_{\text{wafer}} \times \frac{A_i}{A_{\text{wafer}}}
  2. 良率摊薄制造 100 颗只有 70 颗能用，每颗有效成本要除以 0.7。
    Cdie(i)Yi\displaystyle \frac{C_{\text{die}}(i)}{Y_i}
  3. 系统求和所有芯粒的有效制造成本逐项相加。
    ∑i=1NCdie(i)Yi\displaystyle \sum_{i=1}^{N} \frac{C_{\text{die}}(i)}{Y_i}
  4. 封装与测试芯粒越多，先进封装（2.5D/3D）与测试成本 C_pkg 越高，形成约束。
    Ctotal=∑i=1NCdie(i)Yi+Cpkg\displaystyle C_{\text{total}} = \sum_{i=1}^{N} \frac{C_{\text{die}}(i)}{Y_i} + C_{\text{pkg}}

缺陷容忍设计

披萨烤好后，老王发现某块饼边缘焦了一小片。直接扔掉太可惜，他拿刀把焦边切掉，剩下的部分照样卖出好价钱。芯片设计里也有类似的“切焦边”操作，叫缺陷容忍设计。

芯片内部包含大量功能单元（比如 SRAM 存储阵列），设计时多放一些冗余单元（备用行、备用列）。制造完成后，芯片先用自测试（BIST）扫描出哪些单元坏了，再通过熔丝或寄存器配置，把坏单元从电路中隔离，把冗余单元切换上去——相当于用一把“手术刀”把焦边切掉，让芯片“带伤上岗”。

假设一颗芯粒内有 M 个主模块和 R 个冗余模块，每个模块完好的概率都是 p，那么修复后的芯粒良率是：

对存储密集的芯粒，这种冗余修复能把良率从“惨不忍睹”拉到“顺利出货”。老王的“切焦边”手艺，正是芯片内部良率修复的日常版本。

Yrepaired=∑j=0R(M+Rj)(1−p)j p M+R−j\displaystyle Y_{\text{repaired}} = \sum_{j=0}^{R} \binom{M+R}{j} (1-p)^j \, p^{\,M+R-j}
只要坏掉的模块数不超过 R 个，冗余就能全部顶上，芯片依然完好。
  1. 总模块数主模块加冗余模块，一共 M+R 个可用的位置。
    Ntotal=M+R\displaystyle N_{\text{total}} = M + R
  2. 坏模块计数 jj 表示实际损坏的模块个数，j=0 表示全都好，j=1 表示坏一个……
    j=0,1,2,…,R\displaystyle j = 0, 1, 2, \dots, R
  3. 组合数选位从 M+R 个模块中选出 j 个坏模块的摆放方式数。
    (M+Rj)\displaystyle \binom{M+R}{j}
  4. 概率累加把“坏 j 个、好 M+R-j 个”的概率累加起来，只要 j 不超过冗余上限 R 就算成功。
    Yrepaired=∑j=0R(M+Rj)(1−p)j p M+R−j\displaystyle Y_{\text{repaired}} = \sum_{j=0}^{R} \binom{M+R}{j} (1-p)^j \, p^{\,M+R-j}

冗余芯粒策略

锅里的饼偶尔会彻底烤糊，连切焦边都救不回来。老王的应对是：重要的宴席多备几块饼胚，哪块糊了立刻补上。冗余芯粒策略就是这个“多备饼胚”的系统级方案。

在一个 Chiplet 系统里，设计者放置 n 个芯粒，但系统只需 k 个正常工作即可（n>k），多出来的 n-k 个是备用芯粒。当某颗芯粒在测试或运行中被判坏，封装基板上的互联重路由机制会将其隔离，把备用芯粒接入系统，实现热切换。这是典型的 k-out-of-n 系统可靠度模型：

冗余也非免费：备用芯粒占用基板面积、消耗静态功耗，还会增加互联复杂度。但和“整单泡汤”相比，多备一两块饼胚通常是最划算的保险。车规级自动驾驶芯片对此尤其依赖——功能安全要求系统在单点失效下仍能继续运行。

Psys=∑i=kn(ni)pi (1−p)n−i\displaystyle P_{\text{sys}} = \sum_{i=k}^{n} \binom{n}{i} p^i \, (1-p)^{n-i}
系统只要至少 k 颗芯粒存活就能工作，冗余把“全好才可用”的苛刻条件，放宽成“够用就行”。
  1. 存活芯粒数 ii 表示最终完好的芯粒数量，i 必须 ≥ k。
    i=k,k+1,…,n\displaystyle i = k, k+1, \dots, n
  2. 好 i 颗坏 n-i 颗每颗芯粒良率 p，则 i 好、n-i 坏的单种排布概率。
    pi(1−p)n−i\displaystyle p^i (1-p)^{n-i}
  3. 选择排布方式n 颗中哪 i 颗存活，共有组合数种可能。
    (ni)\displaystyle \binom{n}{i}
  4. 累加所有存活情形从 i=k 到 i=n 全部加起来，就是系统可用概率。
    Psys=∑i=kn(ni)pi(1−p)n−i\displaystyle P_{\text{sys}} = \sum_{i=k}^{n} \binom{n}{i} p^i (1-p)^{n-i}

分割优化方案

现在老王掌握了全部工具，开始思考终极问题：一张 AI 大披萨到底该切成几块？切少了，单块太大容易烤糊；切多了，拼盘和包装成本飙升。这是一个最优分割问题，目标是最小化总成本：

求解时还要满足约束：芯粒间总带宽、封装基板面积上限、功耗墙、已知良好芯片（KGD）测试成本等。架构师在流片前用脚本扫描 N=1 到 N=10 的成本曲线，找到谷底——就像老王拿着计算器比较“切 4 块还是切 6 块更赚钱”。

Ctotal(N)=N×Cdie(A/N)Y(A/N)+Cassembly(N)\displaystyle C_{\text{total}}(N) = N \times \frac{C_{\text{die}}(A/N)}{Y(A/N)} + C_{\text{assembly}}(N)
分割数 N 是一把双刃剑：硅制造成本随 N 增大而下降，封装、测试、组装成本却随 N 增大而上升，最优解在 U 型曲线谷底。
  1. 单颗芯粒面积总面积 A 平均分给 N 颗芯粒，每颗面积缩小到 A/N。
    Acell=AN\displaystyle A_{\text{cell}} = \frac{A}{N}
  2. 单颗有效成本面积越小良率越高，摊薄后的单颗成本随之下降。
    Cdie(A/N)Y(A/N)\displaystyle \frac{C_{\text{die}}(A/N)}{Y(A/N)}
  3. 乘上颗数 NN 颗芯粒的硅成本合计。
    N×Cdie(A/N)Y(A/N)\displaystyle N \times \frac{C_{\text{die}}(A/N)}{Y(A/N)}
  4. 组装与设计成本N 增加时，先进封装基板面积、测试工时、设计验证成本非线性上升。
    Cassembly(N)=α×N+β×N2\displaystyle C_{\text{assembly}}(N) = \alpha \times N + \beta \times N^2

AI 应用场景

服务器 CPU 的 IO Die 与计算 Die 拆分

阶段：架构规划与成本分析

解决的问题：传统单片式 CPU 把所有功能放在同一工艺节点，IO 电路占面积大却不需要先进制程，导致整颗芯片制造成本高昂。Chiplet 方案将计算芯粒（先进节点）与 IO 芯粒（成熟节点）分离，用良率模型分别核算成本，使整颗处理器的硅成本下降 30% 以上。

具体案例：AMD EPYC 7000 系列采用 8 颗计算芯粒（7nm）+ 1 颗 IO Die（14nm），IO Die 面积大、良率高、成本低；计算芯粒面积小、良率可控，整体成本相比单片式竞品显著优化。

自动驾驶芯片的冗余安全设计

阶段：DFT（可测试性设计）与功能安全

解决的问题：车规芯片要求 ASIL-D 级功能安全，任何单点失效都不能导致整系统崩溃。冗余芯粒策略与缺陷容忍设计让芯片在部分单元损坏时仍可降级运行，满足“够用即可”的可靠度指标。

具体案例：某自动驾驶 SoC 集成 8 颗 AI 计算芯粒，其中 2 颗为冗余设计，任何一颗失效后系统自动重路由，算力从 100% 降级到 75% 继续工作，车辆可安全驶入应急车道。

流片前的分割方案良率仿真

阶段：设计可行性评估

解决的问题：一次流片成本高达数千万元，盲目选择分割方案风险极大。用良率-成本模型在流片前仿真不同 N 值下的良率与成本曲线，找到最优分割数，避免“切太少良率崩、切太多封装贵”的陷阱。

具体案例：一家 AI 芯片初创公司在 5nm 项目上比较单片式与 4 芯粒、9 芯粒方案，仿真发现 4 芯粒方案总成本最低且良率最优，据此冻结架构，节省了至少两轮流片迭代成本。

Python 演示

python41 行
# -*- coding: utf-8 -*-"""Chiplet 分割良率与成本仿真"""import math def die_yield(area_cm2, defect_density):    return math.exp(-area_cm2 * defect_density) def per_die_cost(die_area_cm2, defect_density, wafer_cost, wafer_area_cm2):    y = die_yield(die_area_cm2, defect_density)    return wafer_cost * (die_area_cm2 / wafer_area_cm2) / y def total_solution_cost(n, area_cm2, defect_density, wafer_cost,                        pkg_cost, assembly_overhead, wafer_area_cm2=706.86):    die_area = area_cm2 / n    y_net = die_yield(die_area, defect_density) ** n    silicon = n * per_die_cost(die_area, defect_density, wafer_cost, wafer_area_cm2)    return silicon + n * (pkg_cost + assembly_overhead), y_net def main():    area = 2.0    dd = 0.3    wafer_cost = 5000.0    pkg_cost = 2.0    assembly = 0.8     y_mono = die_yield(area, dd)    cost_mono, _ = total_solution_cost(1, area, dd, wafer_cost, pkg_cost, assembly)    print("单片方案: 良率 %.1f%%, 总成本 %.2f" % (y_mono * 100, cost_mono))     best_n = 1    best_cost = cost_mono    for n in range(1, 11):        cost, y_net = total_solution_cost(n, area, dd, wafer_cost, pkg_cost, assembly)        print("分割 %2d: 全好概率 %.1f%%, 总成本 %.2f" % (n, y_net * 100, cost))        if cost < best_cost:            best_cost = cost            best_n = n    print("最优分割数: %d, 总成本 %.2f" % (best_n, best_cost)) if __name__ == "__main__":    main()
目的：用泊松良率模型和成本函数，扫描不同分割数 N 下 Chiplet 方案的总成本与全好概率，找出最优分割数。
  1. def die_yield(area_cm2, defect_density):良率公式 Y=e^(-AD)，这是所有计算的地基。
  2. return wafer_cost * (die_area_cm2 / wafer_area_cm2) / y硅片成本按面积占比折算后，再除以良率得到“有效成本”。
  3. y_net = die_yield(die_area, defect_density) ** n计算 N 颗芯粒“全部完好”的概率，验证与单片一致。
  4. silicon + n * (pkg_cost + assembly_overhead)硅成本加上封装与组装成本，构成总成本。
  5. for n in range(1, 11):扫描分割数，寻找 U 型成本曲线的谷底。

常见误区

误区把大芯片切成 4 个小芯粒，每个芯粒面积小了，所以 4 个芯粒全部完好的概率一定比原来大芯片完好的概率高，良率自然就上去了。

正解数学上两者完全相等。每颗芯粒良率 e^(-AD/4)，4 颗全好概率是它的 4 次方，恰好等于 e^(-AD)。拆分本身并不会让“所有部分全部完好”的概率变高。真正的收益来自独立筛选——坏一颗只损失 1/4 面积，加上冗余设计后可用率才大幅提升。

为何常见：人们直觉上把“单颗芯粒良率提升”误当成“系统良率提升”，忽略了芯粒数量增加带来的乘积效应。

误区芯片越大，能放下的晶体管越多，分摊到每个晶体管的缺陷成本越低，所以大芯片更划算。

正解良率公式 Y=e^(-AD) 显示面积 A 是指数项，面积翻倍会让良率按指数暴跌，而不是线性下降。假设 D=0.3/cm²，1cm² 芯片良率 74%，2cm² 芯片良率只有 55%，4cm² 则只剩 30%。“分摊成本”远远赶不上“整片报废”的损失。

为何常见：日常生活中“买大包装更划算”的直觉被套用到半导体上，但良率的指数衰减彻底改变了这个结论。

误区既然做 Chiplet 是为了高性能 AI 芯片，那每一颗芯粒都应该用 3nm/5nm 最先进工艺，才能保证整体性能。

正解先进工艺的晶圆价格是成熟工艺的数倍，而 IO、电源、模拟芯粒对晶体管密度不敏感，用成熟工艺性能几乎不损失、成本却大幅下降。混合工艺节点的精髓是按需匹配：把先进工艺用在真正吃密度的计算芯粒上，其他芯粒用成熟工艺控制总成本。

为何常见：只看“性能上限”而忽略“成本效率”，忘了 Chiplet 的初衷是经济性设计，而不是炫技。

误区既然冗余能提高可靠性，那就多放几颗备用芯粒，比如 12 颗里放 6 颗冗余，系统绝对稳。

正解冗余芯粒占用基板面积、消耗功耗、增加互联和热切换复杂度，而且每颗备用芯粒自己也有缺陷率。系统可靠度 P_sys 随冗余数增加而趋近饱和，但成本近似线性上涨。最优冗余数在“边际可靠性收益 = 边际成本”处取得，而不是越多越好。

为何常见：把可靠性当成免费午餐，忽视了冗余芯粒本身也是“会被烤糊的饼胚”。

面试题

Q1. 良率公式 Y = e^(-AD) 中，D 代表什么含义？

单选题 · easy

  • A.芯片面积的缺陷密度← 正确答案
  • B.芯片输出电压幅度
  • C.设计规则最小线宽
  • D.晶圆直径大小参数

答案：A。D 是单位面积上的平均致命缺陷数（个/cm²），是衡量晶圆厂工艺良率水平的核心参数。B 是电学参数、C 是工艺规则、D 是晶圆尺寸，都与缺陷密度无关。

Q2. 一颗芯片面积 1cm²、缺陷密度 D=0.5/cm²，其良率约为多少？

单选题 · easy

  • A.60.7%← 正确答案
  • B.50.0%
  • C.39.3%
  • D.70.2%

答案：A。由 Y=e^(-AD)=e^(-0.5)≈0.607，良率约 60.7%。A 正确。50% 是线性直觉的错误结果；39.3% 是“有缺陷概率”而非良率；70.2% 无依据。

Q3. 相同总面积下，把芯片等分为 4 个芯粒后，“全部芯粒完好”的概率相比单片方案如何？

单选题 · easy

  • A.明显更低
  • B.明显更高
  • C.完全相同← 正确答案
  • D.无法比较

答案：C。单芯粒良率 e^(-AD/4)，4 颗全好概率为 [e^(-AD/4)]⁴=e^(-AD)，与单片良率恰好相等。拆分的收益不在“全好概率”，而在独立筛选与冗余容错。C 正确。

Q4. 芯片拆分成芯粒后，真正的收益主要来自哪一项？

单选题 · mid

  • A.减小总面积从而减少缺陷
  • B.独立筛选与容错复用← 正确答案
  • C.提高晶体管单位面积密度
  • D.消除全部封装测试开销

答案：B。拆分不改变总面积和全好概率，A 错；晶体管密度由工艺节点决定，C 错；封装测试不会消失反而增加，D 错。独立筛选让坏芯粒只损失 1/N 面积，配合冗余大幅提升可用面积，B 正确。

Q5. 混合工艺节点方案进行芯粒节点分工时，应考虑哪些因素？

多选题 · mid

  • A.逻辑密度与性能需求← 正确答案
  • B.IO 与模拟模块成本← 正确答案
  • C.Die 间接口功耗带宽← 正确答案
  • D.晶圆切割的角度方向

答案：ABC。计算逻辑需要高密度先进节点（A），IO/模拟对密度不敏感用成熟节点降成本（B），Die 间接口的功耗和带宽决定了互联方案与工艺选择（C）。切割角度是制造细节，不决定节点分工（D 错）。

Q6. 下列哪些属于芯粒内部缺陷容忍设计的手段？

多选题 · mid

  • A.冗余存储单元替换坏单元← 正确答案
  • B.片上自测试与熔丝修复← 正确答案
  • C.增大芯片面积摊薄缺陷
  • D.设计备用引脚与备用通路← 正确答案

答案：ABD。冗余单元替换（A）、BIST 自测试加熔丝修复（B）、备用引脚与通路（D）都是典型的缺陷容忍技术。增大面积只会增加缺陷命中概率，C 错误，与容忍设计背道而驰。

Q7. 一颗芯粒内部有 6 个主模块和 2 个冗余模块，每个模块完好概率为 p。修复后芯粒完好的条件是损坏模块数不超过 2 个，其良率表达式为？

单选题 · mid

  • A.p⁶
  • B.1-(1-p)⁸
  • C.Σ(j=0 到 2) C(8,j)(1-p)^j·p^(8-j)← 正确答案
  • D.C(8,2)·p⁶·(1-p)²

答案：C。总模块数 M+R=8，只要坏模块 j≤2 即可。把 j=0、1、2 三种情况的概率累加，即 C(8,j)(1-p)^j·p^(8-j) 的求和。A 只算了全好；B 是“至少一个好”的表达式；D 只算了恰好坏 2 个，漏了坏 0、1 个的情形。

Q8. 系统级冗余芯粒策略中，增加冗余芯粒数量时哪个代价最容易被低估？

单选题 · hard

  • A.冗余芯粒也会同样产生缺陷
  • B.冗余芯粒占用面积、功耗与互联资源← 正确答案
  • C.冗余芯粒无法参与并行计算
  • D.冗余芯粒必须使用更先进工艺

答案：B。冗余芯粒确实自身也有缺陷率（A），但这是良率模型的一部分；不参与并行计算是设计取舍而非隐藏代价（C）；工艺选择与冗余无关（D）。最容易被低估的是每颗冗余芯粒的硅面积、静态功耗和基板布线资源，它们让边际收益快速递减。

Q9. 在 Chiplet 分割优化中，增大分割数 N 通常会带来哪些影响？

多选题 · hard

  • A.提升单颗芯粒的良率← 正确答案
  • B.增加封装测试与组装成本← 正确答案
  • C.使系统全部完好概率下降
  • D.完全消除缺陷带来的损失

答案：AB。N 增大使单颗芯粒面积变小、单颗良率上升（A 对）；但同时芯粒数量增加，封装基板、测试工时、组装成本同步上升（B 对）。“全部完好”概率 e^(-AD) 与 N 无关，C 错；缺陷损失只能减少不能消除，D 错。

Q10. 某单片芯片良率为 20%，将其等分成 4 颗面积相同的芯粒（无冗余），单颗芯粒的良率约为多少？

单选题 · extreme

  • A.55.7%
  • B.66.9%← 正确答案
  • C.80.0%
  • D.48.2%

答案：B。由 Y=e^(-AD)=0.2，等分后单颗良率 p=e^(-AD/4)=0.2^(1/4)。计算 0.2 的四次方根：sqrt(sqrt(0.2))=sqrt(0.447)≈0.669，约 66.9%。A、C、D 均不是 0.2 的四次方根，代入 [e^(-AD/4)]⁴=0.2 即可验证只有 B 成立。