企业官网建设流程全解析

简介：面向计算机体系结构课程学习者与备考人员的《计算机体系结构量化分析》第六版课后答案PDF，聚焦第一章案例与习题的量化推导，适合在阅读教材后核对思路、补齐计算过程。内容围绕芯片制造成本与良品率展开，包含Phoenix与Red Dragon的每片晶圆芯片数、缺陷率下的盈利比较与晶圆分配，单核及Phoenix4/2/1多核良品率分析，芯片面积与成本关系；同时覆盖电压频率变化对能耗和功率的影响、多核部分负载下的能效，以及Amdahl定律对并行加速比的限制。资源包为1个PDF文件，大小3.73MB，结构紧凑，便于按案例和题号检索。已有3613人学习，可作为课程作业对照、考前复习和案例复算的参考材料，帮助读者理解成本效益、良品率优化、能效管理与并行处理局限等关键考点。

1. 从一道良品率题说起：这场考试真正扣分的地方不在公式

计算机体系结构的计算题，挂的人多半不是不会公式，而是单位没对齐、分母放错、把能量当功率。给一片晶圆直径、一个 die 面积、一个缺陷密度，问良品率、问利润、问该投几片晶圆——这是第一章最典型的送分题，也是最能拉开差距的题。第二章往后，缓存 AMAT、DRAM 行缓冲、bank 数、通道利用率，套路一样：先把每个量的单位写清楚，再代公式，最后用极端值验一遍。这份第六版第一、二章的课后答案，价值不在“给出数字”，而在把每一步的中间量摊开给你看。适合两类人：要交作业、要过期末计算题的，和面试里被追问“多核为什么不能一直堆”“直接映射为什么有时反而快”的。

2. 芯片成本与良品率：三个公式撑起第一章的计算题

这一章的题有个共同结构：先算一片晶圆能切多少颗 die，再算这些 die 里有多少是好的，最后乘单价算钱。三步里任何一步单位错位，后面全废。教材案例里两个芯片代号 Phoenix 和 Red Dragon，一个面积 2 cm²、单价 30 美元，一个面积 1.2 cm²、单价 15 美元，看着后者便宜，算完利润反而是后者高。原因就藏在“面积变小→每片切得更多→良品率还更高”这个乘数效应里。

2.1 每片晶圆能切多少 die：724 和 1234 是怎么来的

教材用的公式是DPW = π(d/2)²/S − πd/√(2S)，d 是晶圆有效直径参数，S 是单颗 die 的面积，两项的单位必须统一到 cm。第一项是整片晶圆的面积除以 die 面积，第二项是边缘那些切不完整的 die 的修正。很多人只算第一项，结果数字偏大百分之十左右，一对答案就发现对不上。

Phoenix 的 S=2：第一项 π×22.5²/2 ≈ 795.2，修正项 π×45/√4 ≈ 70.7，相减得 724.5，取整 724。Red Dragon 的 S=1.2：第一项 π×22.5²/1.2 ≈ 1325.4，修正项 π×45/√2.4 ≈ 91.25，相减得 1234。两个数差得不多，但面积小一半，切出来的颗数多了七成，这是后面利润反转的根子。

答这类题时，把“整片面积/die 面积”和“边缘修正”分开写两行，判卷的人一眼能看到你思路完整，即使最后一位取整有出入，过程分也拿得到。

2.2 良品率：指数 14 和括号里的加法都不能动

教材的良品率模型是Yield = 1/(1 + D×A)^14，D 是每平方厘米的缺陷密度，A 是 die 面积，14 是跟工艺步骤数挂钩的经验指数，题目不给就照抄。Phoenix：1+0.04×2=1.08，1.08 的 14 次方约 2.94，倒数 0.34。Red Dragon：1+0.04×1.2=1.048，14 次方约 1.928，倒数 0.519。

面积从 2 降到 1.2，良品率从 0.34 升到 0.52，涨了一半多。这就是“小 die 便宜”的第二层原因：不只切得多，坏的还少。答题时把三个中间量都写出来——括号里的和、幂运算的结果、倒数——比直接甩一个 0.34 稳得多。

提示：缺陷密度如果给的是“每平方毫米多少个”，先乘 100 换成每平方厘米，再代公式。这一步错了，后面全错。

2.3 真题演练：25000 片 Phoenix 和 50000 片 Red Dragon 怎么分晶圆

先算单片晶圆的利润。Phoenix：724 颗 × 0.34 良品率 × 30 美元 = 7384.80 美元。Red Dragon：1234 颗 × 0.519 × 15 美元 = 9601.71 美元。单片晶圆 Red Dragon 多赚两千多，排序清楚。

再看需求上限。25000/724 ≈ 34.5 片，50000/1234 ≈ 40.5 片。教材给出的拆分是 40 片 Red Dragon 加 30 片 Phoenix，逻辑就是单位晶圆利润高的先排满，剩余产能给另一条线，取整时向下取，避免承诺了交不出货。面试官问到这里，最想听的不是数字，而是你先做“单位晶圆利润排序”、再看“需求约束”、最后才谈取整，这三句话的顺序本身就是得分点。

下面这段代码把三步串起来，改参数就能复算别的版本：

def dies_per_wafer(diameter, die_area): # 第一项：整片面积除以 die 面积；第二项：边缘不完整 die 的修正 gross = 3.1416 * (diameter / 2) ** 2 / die_area edge = 3.1416 * diameter / (2 * die_area) ** 0.5 return int(gross - edge) def yield_rate(defect_density, die_area, exponent=14): # 括号里是 1 + 缺陷密度 × 面积，指数固定 14 return 1 / (1 + defect_density * die_area) ** exponent def wafer_profit(diameter, die_area, price, defect_density): dpw = dies_per_wafer(diameter, die_area) y = yield_rate(defect_density, die_area) return dpw * y * price, dpw, round(y, 3) print(wafer_profit(45, 2.0, 30, 0.04)) # Phoenix: 约 7384.8 print(wafer_profit(45, 1.2, 15, 0.04)) # Red Dragon: 约 9601.7

参数说明：diameter是晶圆直径参数，die_area单位 cm²，defect_density单位 defects/cm²，exponent默认 14。dies_per_wafer里两个 π 项必须同单位，wafer_profit返回的第二个值是每片颗数，方便你核对自己的手算中间量。

2.4 多核良品率：二项分布那张表要会读

把 8 核 die 拆成 1 核、2 核、4 核卖，是教材里很经典的一问。单核面积 0.25 cm²，良品率 1/(1+0.04×0.25)^14 ≈ 0.87。接下来是一张组合数表：8 个核里恰好 k 个无缺陷的概率，组合数依次是 1、8、28、56、70、56、28、8、1，概率从 0.328 一路降到 8.16e-08。

要算某个可售配置的良品率，就看这个配置要求“至少几个核正常”，把表里对应的概率加起来。8 核全好是 0.328，7 个好是 0.392，6 个好是 0.205，5 个好是 0.061，4 个好是 0.011。教材的结论是只有 4 核版本值得卖，2 核和 1 核的概率低到 0.0011 和 0.000004，卖出去连测试成本都收不回。

成本那一问也别跳过：一颗 8 核 die 的硅面积能切出约 1.73 颗 4 核 die，所以 4 核版本分摊的成本是 30 + 1.73×25 = 73.25 美元。答题时把“面积比→颗数比→成本分摊”这条链写出来，比只写一个 73.25 有说服力。

3. 功耗与加速比：能量、功率、Amdahl 的分母各写什么

这一章的题最容易混的是三个词：能量、功率、执行时间。电压动，按平方走；频率动，功率按一次方走，能量还要看任务跑了多久。Amdahl 定律则是另一种混：分子分母到底放“可加速比例”还是“不可加速比例”。把这两组关系拆开，第一章后半段的计算题基本就是套。

3.1 能量看电压平方，功率再乘一个频率

动态能量的关系是E ∝ C×V²，动态功率是P ∝ C×V²×f。电压降到 1/8，能量变成 (1/8)²=1/64；如果频率同时也降到 1/8，功率再乘一次 1/8。教材 1.4c 里电压砍半、频率降到 1/8：能量 0.25，功率 0.25×1/8=0.0313，两个数都对得上。

1.4b 那问要留个心眼。按 (1/8)² 推，能量应该是 0.0156，教材印的是 0.156，差一个数量级。考场上别抄结果，把(V/8)²/V²这个式子完整写出来，判卷看的是式子；作业里遇到这种数，旁边标一句“按平方关系应为 0.0156”，反而显得你真懂了。

1.4a 只动频率不动电压，答案给的是能量 1/8、功率不变。这一问考的角度是“同一段程序跑的时间变长了”，别和电压平方那两问混在一起用同一个套路。

3.2 真题：一个核跑 25% 的时间，整机功耗怎么加权

题目场景是四核系统里只有一个核在工作，占 25% 的时间，降频后功率是原来的 20%。算法是两段加权：25% 的时间满功率，功耗贡献 0.25×0.25；剩下 75% 的时间按 20% 功率跑，贡献 0.25×0.2×0.75。加起来 0.0625+0.0375=0.11，也就是原来的 11%。

这类题的关键是把“时间占比”和“功率占比”分开列，别一上来就乘。面试官追问“为什么不是 0.25×0.2”时，你答“因为只有 25% 的时间在跑，另外 75% 时间这颗核不产生动态功耗，要按时间加权”，这一句就把区分度拿到了。

3.3 降频换核心数：4 核跑 1/2.5 频率的那笔账

先用 Amdahl 算加速比：80% 可并行、4 核，1/(0.8/4+0.2)=2.5。也就是说 4 个核各跑原来 1/2.5 的频率，性能才和原来打平。然后算能耗：能量是 4×(1/2.5)²=0.64，功率是 0.64×(1/2.5)=0.256。核心数翻了 4 倍，功率只剩四分之一，这就是“降频多核”的能效账。

再往下一问是 2 个通用核加 2 个专用加速器，算法是(2+0.2×2)/4=0.6：两个专用单元折合 0.4 个通用核的功耗，总共 2.4，除以 4 得 0.6。分子里那个 0.2 是专用单元的功耗系数，题目会给，别自己编。

3.4 Amdahl 定律：分母写错，整题归零

标准形式是加速比 = 1/(可加速比例/加速倍数 + 不可加速比例)。80% 部分快 4 倍：1/(0.8/4+0.2)=2.5。反过来给加速比求可加速比例也要会：若整体加速 2 倍、局部加速 20 倍，解2=1/((1-x)+x/20)得 x=0.526，也就是要向量化 52.6% 的代码。

混合负载的加权加速比是另一个高频变体：1/(0.4/2.46+0.1/2.76+0.5/1.25)=1.67。三项的系数是各负载的时间占比，分母里放的是各自的加速比。有一问里 TPU 算出来 0.33，比 1 还小，原因是某类负载在它上面只有 0.17 的加速比，占比 0.5 直接把整体拖慢——这个“加速器不是万能的”结论，面试里比数字更值钱。

def amdahl(parallel_frac, speedup): # 分母 = 可加速部分/加速倍数 + 不可加速部分 return 1 / (parallel_frac / speedup + (1 - parallel_frac)) def mixed_speedup(weights, speedups): # weights 是各负载时间占比，speedups 是对应加速比 return 1 / sum(w / s for w, s in zip(weights, speedups)) print(round(amdahl(0.8, 4), 2)) # 2.5 print(round(mixed_speedup([0.4, 0.1, 0.5], [2.46, 2.76, 1.25]), 2)) # 1.67 # 已知整体加速比反解可加速比例 def solve_frac(total_speedup, local_speedup): # 2 = 1/((1-x) + x/20) => x = (1 - 1/total) / (1 - 1/local) return (1 - 1 / total_speedup) / (1 - 1 / local_speedup) print(round(solve_frac(2, 20), 3)) # 0.526

solve_frac的推导值得记：设不可加速部分为 1-x，方程两边取倒数后整理，得到(1-1/总加速)/(1-1/局部加速)。考场上现推比背公式稳，因为 Amdahl 的变形题每年都在换壳。

4. 缓存与内存系统：AMAT 与 bank 数的两套算法

第二章的答案分成两块：上半块是缓存，考分块、组相联、平均访存时间；下半块是主存，考 DRAM 的行缓冲命中和 bank 并行。两块题的共同点是“公式不长，但每一步都有个容易漏的项”。分块题漏掉两个矩阵各占一份空间，AMAT 题漏掉周期时间换算，DRAM 题漏掉 transfer time，都是常见的翻车点。

4.1 分块转置：1KB 和 8×8 是怎么定出来的

元素 8 字节，一条 cacheline 64 字节，正好装 8 个元素。分块最小要 8×8=64 个元素，输入矩阵一块占 64×8=512 字节，输出矩阵同样 512 字节，两者相加 1KB，所以最小缓存是 1KB。很多人只算一边，答 512 字节，错在忘了转置要同时读写两个矩阵。

不分块为什么慢：按列访问时，每取一个元素都要拉一整条 64 字节的 line，而列方向涉及 256 行，工作集 64×256=16KB，超过小缓存容量，元素还没被复用就被替换出去了。分块之后，一块内的 64 个元素在缓存里反复用，每个输入输出元素只从内存搬一次。

#define N 256 #define B 8 void transpose_blocked(double out[N][N], double in[N][N]) { for (int i = 0; i < N; i += B) { for (int j = 0; j < N; j += B) { for (int m = 0; m < B; m++) { for (int n = 0; n < B; n++) { // 一次只处理 B×B 的小块，块内数据留在缓存里复用 out[j + n][i + m] = in[i + m][j + n]; } } } } }

B取 8 是因为一条 line 装 8 个 double，块的一行正好对齐一条 line，不会出现一条 line 只用到一半的情况。i、j是块坐标，m、n是块内偏移，四个循环的顺序不能随意换——m在外层保证对in的行访问是连续的，对out的列写入也落在同一块内。

题目还问为什么用 2 路组相联而不是直接映射：直接映射下，输入块和输出块可能映射到同一组，来回替换，分块白做。这一问的答法是“冲突缺失”，不是“容量缺失”，说错类型就丢分。

4.2 AMAT：直接映射为什么反而赢

给一组 miss rate 和命中时间，算平均访存时间AMAT = 命中时间 + 缺失率 × 缺失代价。直接映射 2.2% 缺失、2 个周期，2 路 1.2% 缺失、3 个周期，4 路 0.33% 缺失、2 个周期但周期时间是 0.83ns，8 路 0.09% 缺失、3 个周期、0.79ns。缺失代价统一按 10ns 折算。

直接映射：(1−0.022)×2 + 0.022×20 = 2.396 周期，乘 0.5ns 得 1.2ns。2 路：(1−0.012)×3+0.012×20 = 3.2 周期，1.6ns。4 路：(1−0.0033)×2+0.0033×13 = 2.06 周期，乘 0.83 得 1.69ns。8 路：3 周期×0.79 = 2.37ns。

结论反直觉：缺失率最低的 8 路，AMAT 最差；缺失率最高的直接映射，AMAT 最好。原因在命中时间——多路组相联要先比 tag 再选路，周期时间涨了，缺失率省下的那点收益补不回来。面试里问“缓存越大越好吗”，标准答法就是这一句：先看命中时间涨了多少，再看缺失率降了多少，两头乘完再比。

4.3 DRAM 行缓冲：43ns 和 17ns 要拆成四项

行缓冲缺失时，一次 64 字节读取的延迟是tRP + tRCD + CL + transfer，题目给 13+13+13+4=43ns。行缓冲命中时只要CL + transfer，13+4=17ns。两项的差别就在预充电和行激活，答题时把四项名字写全，别只写 43。

第二个数是通道利用率。连续两次读之间必须等tRP+tRCD+CL=39ns，但通道真正传数据只占 4ns，所以利用率 4/39=10.3%。要把通道跑满，至少需要 10 个 bank——因为 39ns 里可以往 10 个不同 bank 各发一次读，每 4ns 发一个，正好接上。如果访问模式是命中与缺失交替，一次 43ns 里

本文还有配套的精品资源，点击获取