Appearance
数字集成电路设计（进阶）
概念
到这里，站点的"往下看"已经走过两站：硅 · 半导体与器件 讲一个晶体管怎么导通，电 · 电路与数字逻辑 讲几个门怎么组合出加法器和状态机。这一章再往下走一步：几十万个门是怎么变成一块芯片的。
一句话说清它是什么：数字集成电路设计是把"行为描述"逐层翻译成"几何图形"，并在每一层都保证时序、功耗、面积、可测性四项指标达标的过程。
| 层次 | 描述形式 | 谁来做 |
|---|---|---|
| 行为级 | C / MATLAB / 算法模型 | 架构师 |
| RTL 级 | Verilog / VHDL 的可综合子集 | 设计工程师 |
| 门级 | 标准单元 + 连线（网表） | 综合工具 |
| 版图级 | 多边形几何图形（GDSII） | 布局布线工具 |
每一层的翻译都由工具完成，但每一层都要人来"约束"——工具只负责满足约束，不负责判断约束对不对。
这一层回答了上一层什么问题：上一章的 综合实践 讲的是"怎么把芯片用起来"；这一章讲"这颗芯片本身是怎么被设计出来的"。它与 电路与数字逻辑 的时序分析同源——局部的那套 setup/hold 与 slack，放到整颗芯片上就是 静态时序分析（STA）。
原理
一、七步流程
text
规格定义
-> 1. RTL 设计 写 Verilog，只保证功能
-> 2. 功能验证 仿真，覆盖率收敛
-> 3. 逻辑综合 映射到标准单元 -> 门级网表
-> 4. DFT 插入 加扫描链，让芯片"能测"
-> 5. 布局布线 布局 / 时钟树 / 布线 -> 版图
-> 6. 时序与物理签核 STA / IR drop / 串扰 / DRC-LVS
-> 7. 流片、封装、测试 掩模、晶圆制造、ATE 测试第 3 步与第 5 步是这道流程的两个分水岭：
- 综合把"行为"变成"门"。这一步之前，代码写错了只是功能不对；这一步之后，时序开始成为硬约束。
- 布局布线把"门"变成"几何"。这一步之前，延迟主要来自门的固有延迟；这一步之后，连线延迟开始占主导。在现代工艺（比如 28 nm 以下），互连延迟往往超过门延迟，这就是为什么"布局布线的结果不能靠综合的报告来预测"。
二、综合：翻译 + 优化 + 映射
综合工具干三件事：
- 翻译：把 RTL 化成与工艺无关的布尔网络（Gtech）；
- 逻辑优化：常量传播、公共子表达式提取、布尔化简——与 优化的思路 完全一致，只不过这里的"指令"换成了"门"；
- 映射：把优化后的布尔网络落到标准单元库里的具体单元上。
标准单元库是一组预先设计好、已经画好版图的逻辑单元（反相器、NAND2、DFF……），每个单元都带一组"延迟 / 面积 / 功耗"参数表。同一个逻辑功能往往有多个版本：
| 单元变体 | 特点 | 什么时候用 |
|---|---|---|
| NAND2_X1 | 驱动能力小、面积小 | 负载轻、不在关键路径上 |
| NAND2_X4 | 驱动能力强、面积大 | 关键路径、扇出大 |
| NAND2_LVT | 阈值低、快、漏电大 | 关键路径 |
| NAND2_HVT | 阈值高、慢、漏电小 | 非关键路径 |
"用 HVT 填满非关键路径、只给关键路径用 LVT" 是低功耗设计的标准手法。多阈值单元的存在，正是把"速度与漏电的取舍"做成了工具可以自动挑选的选项。
三、工艺角与静态时序分析
同一个设计，在同一个工艺下，做出来的芯片快慢是不一样的。 工艺波动 + 电压波动 + 温度波动（合称 PVT）组合出若干个必须都通过的工艺角：
| 工艺角 | 晶体管 | 用途 |
|---|---|---|
| SS Slow-Slow | 慢 | 建立时间（setup）最差 |
| FF Fast-Fast | 快 | 保持时间（hold）最差 |
| TT | 典型 | 中间参考 |
| SF / FS | 混合 | 检查某些特殊路径 |
为什么"最快"反而最差——这是时序里最常见的困惑：保持时间要求"新数据不能来得太早"，数据路径越快，越容易冲过捕获触发器，所以hold 要在 FF 角检查；建立时间要求"数据不能来得太晚"，所以 setup 要在 SS 角检查。
静态时序分析（STA）就是在这个背景下，对所有路径做的时序检查。它不跑激励、不算功能，只算延迟：
text
建立时间：slack_setup = T_clk - (t_co + t_logic,max + t_su) + t_skew
保持时间：slack_hold = t_co + t_logic,min - t_hold - t_skew
最高频率：f_max = 1 / (t_co + t_logic,max + t_su - t_skew + t_jitter)三条判据都要 slack >= 0，即所有工艺角下的最坏值都要满足。注意几个口径（与 数字电路的时序分析 完全一致）：
- setup 公式含
t_logic,max、含t_su；hold 公式不含T_clk、用t_logic,min——hold 与时钟周期无关，这是它最反直觉的一点。 t_skew是"捕获时钟 − 发射时钟"：正偏斜帮 setup、害 hold。t_jitter只进f_max公式（时钟抖动是频率指标的一部分），不进 slack 公式。
四、互连延迟：从门延迟到线延迟
工艺越先进，线越细、越长，电阻电容越占主导。一条分布 RC 线的延迟用 Elmore 模型：
text
把总电阻 R、总电容 C 的线分成 N 段
Elmore 延迟 = R*C*(N+1)/(2N)| N | 1 | 2 | 5 | 10 | 100 | → ∞ |
|---|---|---|---|---|---|---|
| 系数 | 1.0000 | 0.7500 | 0.6000 | 0.5500 | 0.5050 | 0.5000 |
N 很大时收敛到 RC/2——这解释了为什么"长线必须插缓冲器（repeater）"：插了缓冲器相当于把线切成多段，把延迟从 RC 压向 RC/2，同时把驱动器阻抗降下来。
线还带来两个非时序问题：
| 现象 | 原因 | 后果 |
|---|---|---|
| 串扰 Crosstalk | 相邻线之间的耦合电容 | 一跳变就干扰邻居，可能造成功能错误 |
| IR drop | 电源线的电阻压降 | 局部电压不足，延迟变大甚至失效 |
五、功耗的四个来源
一个数字单元的功耗分四块：
| 来源 | 公式 | 特点 |
|---|---|---|
| 动态（翻转） | P = alpha*C*V^2*f | 占主导，与频率、电压平方成正比 |
| 短路 | 翻转瞬间两管同时导通 | 通常占动态的 10%~20% |
| 静态泄漏 | P = I_leak * V | 与频率无关，工艺越先进占比越大 |
| 浪涌 / 上下电 | — | 只在电源切换时出现 |
alpha 是翻转率（每个时钟周期里有多少比例的门真的在翻转），它是功耗优化的第一号目标——时钟门控（clock gating） 就是把不工作的模块的时钟关掉，直接让那一块的 alpha 变 0。
V^2 这一项是 DVFS（动态电压频率调节）的全部理由：电压降 25%，动态功耗直接降到 56%；电压降 25% 同时频率降 25%，降到 42%。先降电压、再降频率，顺序不能反（电压不够时高频根本跑不起来）。
六、成本：晶圆、良率与单颗价格
芯片的成本几乎全部在面积上：面积决定一片晶圆能切多少颗，也决定良率。近似算法：
text
每片晶圆毛颗数 N ≈ pi*D^2/(4*S) - pi*D/sqrt(2*S) （D = 晶圆直径，S = 单颗面积）
良率 Y ≈ 1 / (1 + A*D0) （A = 单颗面积 cm^2，D0 = 缺陷密度 /cm^2）
单颗成本 = 晶圆价格 / (N * Y)第二个式子是简化模型（不同良率模型给出的曲线不同，见考点里的提醒），但它抓住了最重要的两件事：
- 面积越大，
N下降得比线性还快（因为圆的边缘浪费更多）； - 面积越大，良率也越低（大芯片更容易踩到缺陷）。
这两条叠加，使"面积"成为 IC 设计里唯一真正昂贵的东西——它同时决定了产能与良率。这解释了为什么架构师会为了省 5% 的面积而大改设计。
七、可测性：DFT 与边界扫描
芯片出厂必须测试，但几十万个内部节点根本没法用探针碰。解决办法是把测试做成设计的一部分：
| 手段 | 做法 |
|---|---|
| 扫描链 | 把触发器串成移位寄存器，测试时直接把值移进去、把结果移出来 |
| 扫描覆盖率 | 能被扫描链观测到的故障点所占比例，是签核指标之一 |
| 边界扫描 JTAG | 芯片引脚之间的扫描链，用 IEEE 1149.1 协议从外部访问 |
| ATE 测试 | 自动测试机按测试向量逐颗测，测试成本常常超过制造成本 |
"设计的时候就得想好怎么测" 是 IC 与软件最大的文化差异之一：软件可以随时打补丁，流片回来的芯片不能。
示例
例 1：一条路径的 slack 与最高频率
取 t_co = 0.9 ns、t_logic = 7.2 ns、t_su = 0.8 ns、t_skew = 0.3 ns、t_jitter = 0.1 ns：
text
组合总延迟 = 0.9 + 7.2 + 0.8 - 0.3 = 8.60 ns
f_max = 1 / (8.60 + 0.1) = 1 / 8.70 ns = 114.9425 MHz
在 100 MHz（T = 10 ns）下：slack = 10 - 8.60 = +1.40 ns MET换成三个工艺角（SS 乘 1.4、TT 乘 1.0、FF 乘 0.7）：
| 工艺角 | 系数 | 组合总延迟 (ns) | f_max (MHz) | 100 MHz 下 slack (ns) |
|---|---|---|---|---|
| SS 慢 | 1.4 | 12.16 | 81.57 | −2.16（违例） |
| TT 典型 | 1.0 | 8.60 | 114.94 | +1.40 |
| FF 快 | 0.7 | 5.93 | 165.84 | +4.07 |
TT 角算出来 114.94 MHz、看着很宽裕，但 SS 角只有 81.57 MHz——所以签核必须按 SS 角定频率。这就是"实验室里跑 100 MHz 没问题，量产有的芯片起不来"的完整解释。
例 2：动态功耗与 DVFS
取 alpha = 0.15、C = 2 nF、V = 1.2 V、f = 100 MHz：
text
动态功耗 = 0.15 * 2 nF * 1.2^2 * 100 MHz = 43.200 mW
泄漏功耗 = 5 mA * 1.2 V = 6.000 mW
总功耗 = 49.200 mW，其中泄漏占 12.20%降压降频的组合效果：
| V | f | 动态功耗 | 相对基线 |
|---|---|---|---|
| 1.2 V | 100 MHz | 43.200 mW | 100.00% |
| 0.9 V | 100 MHz | 24.300 mW | 56.25% |
| 0.9 V | 75 MHz | 18.225 mW | 42.19% |
| 0.75 V | 50 MHz | 8.438 mW | 19.53% |
只降压不降频就省了 43.75%，这就是 V^2 的威力；再叠加降频才到 42.19%。注意泄漏那 6 mW 一直没动——它是硬底，alpha 降到 0 也省不掉，所以低功耗的下一步必然是"换更高阈值的单元"或"关掉整块电源域"。
例 3：面积、晶圆产出与单颗成本
取 300 mm 晶圆、单颗面积 100 mm²：
text
毛颗数 N = pi*300^2/(4*100) - pi*300/sqrt(200) = 706.86 - 66.64 = 640.22 -> 640 颗
良率 Y = 1 / (1 + 1.0 * 0.2) = 0.8333 -> 好颗数 533
晶圆 $4000 -> 每颗好 die $7.50
晶圆 $8000 -> 每颗好 die $15.00
晶圆 $17000 -> 每颗好 die $31.87注意 pi*D/sqrt(2*S) 那一项：它是圆形边缘浪费的修正项——圆的边界切不出完整的方 die。这也是"小芯片比大芯片划算"的一部分来源。
例 4：互连为什么必须插缓冲器
一条总电阻 1 kΩ、总电容 100 fF 的线（RC = 100.0 ps），看它被切成 N 段后的 Elmore 延迟：
text
N = 1 : 100.0000 ps
N = 2 : 75.0000 ps
N = 5 : 60.0000 ps
N = 10 : 55.0000 ps
N = 100 : 50.5000 ps
N -> inf : 50.0000 ps (RC/2)从 1 段到 10 段砍掉 45%，从 10 段到无穷只再砍 9%——所以插缓冲器不是越多越好，插多了会引入额外的门延迟与面积。这也是为什么 EDA 工具里有"缓冲器插入与尺寸优化"这一步，它在做这个取舍。
例 5：C 实现——小网表的静态时序分析
一个只有三个门的小网表，算到达时间、还原关键路径、判 slack。
/* sta.c —— 小网表的静态时序分析：到达时间、关键路径与 slack */
#include <stdio.h>
#define NNODE 6
typedef struct {
const char *name;
int fanin[2]; /* 关键前驱编号；输入端口为 -1 */
double delay; /* 本门延迟（含负载），ns */
double arr; /* 到达时间，ns */
int crit; /* 贡献了到达时间的那个前驱 */
} Node;
static Node node[NNODE] = {
{ "A", {-1, -1}, 0.00, 0.00, -1 },
{ "B", {-1, -1}, 0.00, 0.00, -1 },
{ "C", {-1, -1}, 0.00, 0.00, -1 },
{ "AND(A,B)", { 0, 1}, 0.30, 0.00, -1 },
{ "OR(B,C)", { 1, 2}, 0.25, 0.00, -1 },
{ "XOR(n3,n4)", { 3, 4}, 0.45, 0.00, -1 }
};
int main(void)
{
int i, k;
printf("=== 1. gate netlist ===\n");
for (i = 0; i < NNODE; i++) {
if (node[i].fanin[0] < 0)
printf(" n%d %-12s input\n", i, node[i].name);
else
printf(" n%d %-12s <== n%d, n%d delay %.2f ns\n",
i, node[i].name, node[i].fanin[0], node[i].fanin[1], node[i].delay);
}
printf("\n=== 2. arrival time (worst path) ===\n");
for (i = 3; i < NNODE; i++) {
double a = node[node[i].fanin[0]].arr, b = node[node[i].fanin[1]].arr;
node[i].crit = (a >= b) ? node[i].fanin[0] : node[i].fanin[1];
node[i].arr = (a >= b ? a : b) + node[i].delay;
printf(" n%d %-12s arr = max(%.2f, %.2f) + %.2f = %.2f ns\n",
i, node[i].name, a, b, node[i].delay, node[i].arr);
}
printf("\n=== 3. critical path ===\n ");
for (k = NNODE - 1; k >= 0; k = node[k].crit) printf("%s -> ", node[k].name);
printf("(%.2f ns)\n", node[NNODE - 1].arr);
printf("\n=== 4. timing check (t_co = 0.20 ns, t_su = 0.10 ns) ===\n");
for (i = 0; i < 2; i++) {
double T = i == 0 ? 1.20 : 1.00;
double slack = T - (0.20 + node[NNODE - 1].arr + 0.10);
printf(" T = %.2f ns (%.2f MHz): slack = %.2f - (0.20 + %.2f + 0.10) = %+.2f ns %s\n",
T, 1000.0 / T, T, node[NNODE - 1].arr, slack, slack >= 0 ? "MET" : "VIOLATED");
}
return 0;
}
c 本站为静态站，不提供在线运行；可复制到本地用 gcc / python 执行
预期输出：
=== 1. gate netlist ===
n0 A input
n1 B input
n2 C input
n3 AND(A,B) <== n0, n1 delay 0.30 ns
n4 OR(B,C) <== n1, n2 delay 0.25 ns
n5 XOR(n3,n4) <== n3, n4 delay 0.45 ns
=== 2. arrival time (worst path) ===
n3 AND(A,B) arr = max(0.00, 0.00) + 0.30 = 0.30 ns
n4 OR(B,C) arr = max(0.00, 0.00) + 0.25 = 0.25 ns
n5 XOR(n3,n4) arr = max(0.30, 0.25) + 0.45 = 0.75 ns
=== 3. critical path ===
XOR(n3,n4) -> AND(A,B) -> A -> (0.75 ns)
=== 4. timing check (t_co = 0.20 ns, t_su = 0.10 ns) ===
T = 1.20 ns (833.33 MHz): slack = 1.20 - (0.20 + 0.75 + 0.10) = +0.15 ns MET
T = 1.00 ns (1000.00 MHz): slack = 1.00 - (0.20 + 0.75 + 0.10) = -0.05 ns VIOLATED这一段程序就是 STA 的骨架：工具做的事情一样，只是节点有几百万个、还要带工艺角与串扰修正。关键路径 XOR -> AND -> A 的延迟 0.75 ns 加上触发器的 t_co 0.20 与 t_su 0.10 得到 1.05 ns，所以时钟周期必须 >= 1.05 ns，即 952.38 MHz 是理论上限——在 1.00 ns 下 slack 为负，程序如实报出 VIOLATED。
例 6：Python——时序、功耗、面积与成本一起算
# 数字 IC：工艺角时序、功耗与 DVFS、晶圆产出、互连 Elmore
import math
import unicodedata
def wpad(s, n):
"""按显示宽度右补空格：东亚宽字符算 2 列"""
w = sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in s)
return s + " " * max(0, n - w)
t_co, t_logic, t_su, t_skew, t_jitter = 0.9, 7.2, 0.8, 0.3, 0.1
T = 10.0 # 100 MHz
print("=== 一、时序：最高频率与 slack ===")
comb = t_co + t_logic + t_su - t_skew
print(f"组合总延迟 = {t_co} + {t_logic} + {t_su} - {t_skew} = {comb:.2f} ns")
print(f"f_max = 1 / ({comb:.2f} + {t_jitter}) = {1 / (comb + t_jitter) * 1e3:.4f} MHz")
print(f"T = {T:.0f} ns 时 slack = {T:.2f} - {comb:.2f} = {T - comb:+.2f} ns")
print("\n 工艺角 系数 组合总延迟 f_max slack@100MHz")
for name, s in [("SS 慢", 1.4), ("TT 典型", 1.0), ("FF 快", 0.7)]:
comb2 = s * (t_co + t_logic + t_su) - t_skew
fm = 1 / (comb2 + t_jitter) * 1e3
print(f" {wpad(name, 8)}{s:4.1f}{comb2:12.2f} ns{fm:10.2f} MHz{T - comb2:+12.2f} ns"
f"{' 违例' if T - comb2 < 0 else ''}")
print("\n=== 二、功耗与 DVFS ===")
alpha, C, V, f = 0.15, 2e-9, 1.2, 100e6
P_base = alpha * C * V ** 2 * f
P_leak = 5e-3 * 1.2
print(f"动态 = {alpha} x {C * 1e9:.0f} nF x {V}^2 x {f / 1e6:.0f} MHz = {P_base * 1e3:.3f} mW")
print(f"泄漏 = 5 mA x {V} V = {P_leak * 1e3:.3f} mW，占总量 {P_leak / (P_base + P_leak) * 100:.2f}%")
for v, ff in [(1.2, 100e6), (0.9, 100e6), (0.9, 75e6), (0.75, 50e6)]:
p = alpha * C * v ** 2 * ff
print(f" V={v} V, f={ff / 1e6:3.0f} MHz -> {p * 1e3:7.3f} mW，为基线的 {p / P_base * 100:6.2f}%")
print("\n=== 三、面积、晶圆产出与良率 ===")
D, S = 300.0, 100.0
raw = math.pi * D ** 2 / (4 * S) - math.pi * D / math.sqrt(2 * S)
Y = 1 / (1 + 1.0 * 0.2)
print(f"300 mm 晶圆，单颗 {S:.0f} mm2 -> 毛颗数 = pi*D^2/(4S) - pi*D/sqrt(2S) = {raw:.2f} -> {int(raw)} 颗")
print(f"良率 Y = 1/(1 + A*D0) = 1/(1 + 1.0*0.2) = {Y:.4f} -> 好颗数 {int(raw) * Y:.0f}")
for cost in (4000, 8000, 17000):
print(f" 晶圆 ${cost:6d} -> 单颗好 die ${cost / (int(raw) * Y):.2f}")
print(f"面积账：2000000 等效门 / 20000 门每 mm2 = {2000000 / 20000:.1f} mm2")
print("\n=== 四、互连 Elmore（分布 RC）===")
R, Cw = 1e3, 100e-15
print(f"R = {R:.0f} ohm, C = {Cw * 1e15:.0f} fF -> RC = {R * Cw * 1e12:.1f} ps")
for n in (1, 2, 5, 10, 100, 10000):
print(f" 分 {n:5d} 段: Elmore = RC*(N+1)/(2N) = {R * Cw * (n + 1) / (2 * n) * 1e12:.4f} ps")
print(f" N 趋于无穷的极限 = RC/2 = {R * Cw / 2 * 1e12:.4f} ps")
python 本站为静态站，不提供在线运行；可复制到本地用 gcc / python 执行
预期输出：
=== 一、时序：最高频率与 slack ===
组合总延迟 = 0.9 + 7.2 + 0.8 - 0.3 = 8.60 ns
f_max = 1 / (8.60 + 0.1) = 114.9425 MHz
T = 10 ns 时 slack = 10.00 - 8.60 = +1.40 ns
工艺角 系数 组合总延迟 f_max slack@100MHz
SS 慢 1.4 12.16 ns 81.57 MHz -2.16 ns 违例
TT 典型 1.0 8.60 ns 114.94 MHz +1.40 ns
FF 快 0.7 5.93 ns 165.84 MHz +4.07 ns
=== 二、功耗与 DVFS ===
动态 = 0.15 x 2 nF x 1.2^2 x 100 MHz = 43.200 mW
泄漏 = 5 mA x 1.2 V = 6.000 mW，占总量 12.20%
V=1.2 V, f=100 MHz -> 43.200 mW，为基线的 100.00%
V=0.9 V, f=100 MHz -> 24.300 mW，为基线的 56.25%
V=0.9 V, f= 75 MHz -> 18.225 mW，为基线的 42.19%
V=0.75 V, f= 50 MHz -> 8.438 mW，为基线的 19.53%
=== 三、面积、晶圆产出与良率 ===
300 mm 晶圆，单颗 100 mm2 -> 毛颗数 = pi*D^2/(4S) - pi*D/sqrt(2S) = 640.22 -> 640 颗
良率 Y = 1/(1 + A*D0) = 1/(1 + 1.0*0.2) = 0.8333 -> 好颗数 533
晶圆 $ 4000 -> 单颗好 die $7.50
晶圆 $ 8000 -> 单颗好 die $15.00
晶圆 $ 17000 -> 单颗好 die $31.87
面积账：2000000 等效门 / 20000 门每 mm2 = 100.0 mm2
=== 四、互连 Elmore（分布 RC）===
R = 1000 ohm, C = 100 fF -> RC = 100.0 ps
分 1 段: Elmore = RC*(N+1)/(2N) = 100.0000 ps
分 2 段: Elmore = RC*(N+1)/(2N) = 75.0000 ps
分 5 段: Elmore = RC*(N+1)/(2N) = 60.0000 ps
分 10 段: Elmore = RC*(N+1)/(2N) = 55.0000 ps
分 100 段: Elmore = RC*(N+1)/(2N) = 50.5000 ps
分 10000 段: Elmore = RC*(N+1)/(2N) = 50.0050 ps
N 趋于无穷的极限 = RC/2 = 50.0000 ps四段账要连起来读：时序（例一）决定这颗芯片能标多少频率，功耗（例二）决定它要不要散热片，面积与良率（例三）决定它卖多少钱，互连（例四）决定时序里有多少是"线"贡献的、而不是门贡献的。这四项互相拉扯——想快就要用 LVT 单元（漏电涨）、想省面积就要减缓冲器（延迟涨），IC 设计的日常就在这几条曲线上找平衡点。
考点
- 七步流程：RTL → 验证 → 综合 → DFT → 布局布线 → 签核 → 流片。综合之后时序成为硬约束，布局布线之后互连延迟开始占主导。
- 综合 = 翻译 + 逻辑优化 + 映射到标准单元库；多阈值单元（LVT / HVT）存在的原因就是把"速度与漏电"变成工具可自动挑选的选项。
- 工艺角：setup 查 SS 角（慢）、hold 查 FF 角（快）。这一点极容易记反——"最快的角最差"指的是 hold。
- 三条时序公式：
slack_setup = T - (t_co + t_logic,max + t_su) + t_skew；slack_hold = t_co + t_logic,min - t_hold - t_skew（不含 T）；f_max = 1/(t_co + t_logic,max + t_su - t_skew + t_jitter)。t_jitter只进f_max，不进 slack。 t_skew是"捕获时钟 − 发射时钟"：正偏斜帮 setup、害 hold。- 互连的 Elmore 延迟 =
RC(N+1)/(2N)，N 大时趋近RC/2。这是"长线插缓冲器"的全部依据。 - 功耗四项：动态
alpha*C*V^2*f、短路、静态泄漏I*V、浪涌。DVFS 靠的是V^2，先降压再降频。泄漏与频率无关，是低功耗的硬底。 - 良率与面积：面积同时决定产能（
N）与良率（Y），所以面积是 IC 里唯一真正昂贵的东西。 - 可测性必须做进设计里：扫描链 + 边界扫描（JTAG，IEEE 1149.1）。软件可以打补丁，流片回来的芯片不能。
- 易错：把 hold 检查放在 SS 角（应放 FF 角）；把
t_jitter加进 slack 公式；认为"TT 角通过就万事大吉"；把良率模型1/(1+A*D0)当成精确公式（它只是简化模型，不同模型曲线不同，但趋势一致：面积越大良率越低）；把"频率高"直接等同于"性能好"（互连延迟与功耗都是代价）。
小结
- IC 设计是一条"逐层翻译 + 每层加约束"的流水线：行为 → RTL → 门级 → 版图，工具负责满足约束，人负责保证约束正确。
- 两个分水岭：综合（时序变成硬约束）、布局布线（互连延迟占主导）。
- 工艺角让同一设计有快慢之分，所以签核取最坏角：setup 看 SS、hold 看 FF。
- STA 的三条公式把"能不能跑这个频率"变成一个不等式；
slack >= 0是唯一判据。 - 互连遵循 Elmore，N 大时趋近
RC/2；插缓冲器的收益递减。 - 功耗 = 动态 + 短路 + 泄漏 + 浪涌，动态靠
V^2与alpha打，泄漏是硬底。 - 面积决定成本，因为它同时决定产能与良率。
- DFT 不是可选项：芯片不能打补丁，所以"怎么测"必须在设计阶段就解决。
回到主线：这一章把 器件、CMOS 结构、缩放规律、时序分析、可综合的 Verilog、FPGA 与 ASIC 的取舍、流水线的频率上限 全都用了一遍——它同时是 silicon、circuit、arch 三层的下游，也是 embed 这条分支的终点：从"用芯片"回到"造芯片"，一个完整的圆。
到这里，embed 分支讲完了：从微机原理、中断、ARM、GPIO、三种串行总线、RTOS，到把芯片本身设计出来。它之外还剩一门与主线关系最弱的课——那里管的不再是"芯片怎么算",而是"怎么让一个物理量稳定地停在你要的值上"。
下一篇：自动控制概论：开环与闭环
评论（0）
当前浏览器不允许本地存储，评论无法保存。
还没有评论，来说两句。