企业官网建设流程全解析

简介：《计算机组成原理第六版习题解析》PDF面向计算机专业学生、考研复习者及授课教师，针对第六版教材课后习题提供系统解析，帮助读者核对解题思路、定位薄弱知识点。资源包共1个PDF文件，大小约3.93MB，文档可检索、便于打印和分章复习，适合配合课堂学习或考前查漏补缺。已有11455人学习下载，说明其在计算机基础课复习中具有较高参考价值。内容可围绕中央处理器结构、存储器分类、总线结构、指令系统、性能指标等章节展开，结合习题答案梳理计算机系统五大组成部分之间的联系，并对照教材例题理解解题步骤，从而提升复习效率与概念掌握程度。

1. 习题解析的真正价值：把“算对了”还原成“机器里发生了什么”

很多人刷计算机组成原理的题，止步于对答案：CPI 算对了、命中率算对了、总线带宽算对了，就翻页。可只要题目换个问法，把直接映射改成组相联，把单总线改成双总线，把机器周期从 4 个改成 3 个，同一套公式立刻失灵。原因不复杂：习题考的不是算术，而是每条公式背后那台机器的时序与数据流向。这份按题号组织的习题解析，价值不在给出成组的答案，而在于把每道题还原成取指、译码、执行、访存、写回这几步微操作，让你看见参数一改，到底哪一级先崩。搞清楚这一点，公式才不再是玄学。

2. 五大部件与指令周期：一条指令到底怎么在机器里跑完

计算机组成原理最容易被习题带偏的地方，是把五大部件当成五个名词来背。输入设备、输出设备、存储器、运算器、控制器，背下来只要十秒，可题目一问“取指阶段哪些部件参与”“MAR 和 MDR 分别贴在哪一侧”，就只能凭印象。真正该建立的图景是：指令和数据共享同一片存储空间，一条指令从地址到结果，是一条有严格先后顺序的微操作链，链上任何一个寄存器少走一步，后面的时序全错。

2.1 存储程序：指令和数据为什么共享一个存储器

存储程序思想的核心只有一句：把指令当成数据一样存进存储器，由 PC 给出地址，机器自己去取。这样一来，存储器看到的只有二进制位，它并不知道哪块是指令、哪块是操作数，区分完全靠“当前处于取指阶段还是取数阶段”。这条设计带来两个直接后果，也是习题反复考的点。

第一，指令地址由 PC 提供，操作数地址由指令中的形式地址加寻址方式算出，两者走的是同一组地址线，但来源不同。第二，取指和取数都会访存，但取指访存拿到的是指令字，送进 IR；取数访存拿到的是数据字，送进通用寄存器或累加器。很多同学在“一条指令访存几次”的题上翻车，根源就是把这两类访存混成了一次。

与之相对的是哈佛结构，指令存储器和数据存储器物理分开，可以同时取指和取数，数字信号处理类芯片里常见。教科书模型大多按冯·诺依曼结构走，因为它的结构简单、地址空间统一，代价是取指和取数争抢同一套存储器接口，这就是常说的冯·诺依曼瓶颈。理解这个瓶颈，后面算总线带宽、算流水线加速比时才有落脚点。

2.2 取指—译码—执行：一条加法指令的完整时序

把一条ADD R1, [addr]拆到微操作级别，能看清寄存器之间的搬运路径。下面这段极简模型不是为了跑真实程序，而是把教材里的寄存器传送关系钉死，方便对照习题里的时序图。

class SimpleDatapath: def __init__(self, memory): self.mem = memory # 存储器：地址 -> 16 位字 self.pc = 0 # 程序计数器，指向下一条指令 self.mar = 0 # 地址寄存器，接存储器地址端 self.mdr = 0 # 数据寄存器，接存储器数据端 self.ir = 0 # 指令寄存器，存放当前指令 self.acc = 0 # 累加器，暂存运算结果 self.cycles = 0 # 累计时钟周期数 def fetch(self): self.mar = self.pc # 微操作1：PC -> MAR self.mdr = self.mem[self.mar] # 微操作2：存储器读，结果进 MDR self.ir = self.mdr # 微操作3：MDR -> IR self.pc += 1 # 微操作4：PC 自增，指向下一条 self.cycles += 4 # 教材模型常按 4 个时钟计取指 def execute(self): op = (self.ir >> 12) & 0xF # 高 4 位为操作码 addr = self.ir & 0x0FFF # 低 12 位为形式地址 if op == 0x1: # LOAD：取数到累加器 self.mar = addr self.mdr = self.mem[self.mar] self.acc = self.mdr self.cycles += 3 elif op == 0x2: # ADD：累加器加内存操作数 self.mar = addr self.mdr = self.mem[self.mar] self.acc = (self.acc + self.mdr) & 0xFFFF self.cycles += 3 elif op == 0xF: # HALT：停机 return False return True

这段代码里有三条路径值得记住。PC -> MAR -> 存储器 -> MDR -> IR是取指路径，中间必须经过 MAR 和 MDR，因为 CPU 不能直接把 PC 接到存储器的数据线上，地址和数据在时序上要分开。PC + 1在取指阶段就完成，这样下一条指令的地址提前准备好，为流水线做铺垫。执行阶段的addr -> MAR -> MDR -> ALU是取数路径，它和取指路径复用同一组存储器接口，所以顺序执行时两者不能重叠。

参数上，操作码占高 4 位意味着最多 16 条指令，形式地址 12 位意味着直接寻址范围是 4K 字。题目如果把操作码改成 6 位、地址改成 10 位，直接寻址范围立刻缩到 1K 字，这就是指令格式题里“位数一挪，寻址空间就变”的由来。取指占 4 个时钟、执行占 3 个时钟只是教材模型的一种约定，真按题给时序图走，每个微操作占几个时钟要看具体设定，不能拿固定数字套。

2.3 机器周期与时钟周期：时序信号把微操作串起来

时钟周期是机器里最小的时间单位，由晶振频率取倒数得到。机器周期又叫 CPU 周期，通常由若干个时钟周期组成，对应完成一次总线传输或者一次 ALU 运算这类动作。指令周期则是执行一条完整指令所需的时间，由若干个机器周期拼成。三者的关系是包含关系，不是并列关系，习题里最常见的错误就是把它们当成同一层概念，直接拿时钟周期去除以指令条数。

取指周期、间址周期、执行周期、中断周期这四类机器周期，在有的教材里用四个触发器状态来标识。取指周期做的是公事，所有指令都一样；间址周期只在间接寻址时出现；执行周期因指令而异；中断周期在响应中断时插入。判断某条指令需要几个机器周期，本质上是判断它需不需要间址、需不需要多次访存。

时序信号的作用是把微操作分配到具体的时钟边沿上。同一时刻只能有一个信息从一个源流向一个目的，否则总线冲突。比如PC -> MAR和MDR -> IR可以放在不同时钟，但如果把PC -> MAR和PC + 1放进同一个时钟，就要看 PC 是否有两套输出端口，多数模型里没有，只能串行。这类“同一时钟内允许发生哪些微操作”的判断，是时序题真正的考点，靠背答案背不出来，得把数据通路图上的每条线走一遍。

3. CPU 数据通路：控制单元、ALU 与寄存器怎么对齐时序

指令周期的题做顺了，下一步就会撞上数据通路。教材里的 CPU 内部结构图看着复杂，拆开只有三类东西：存东西的寄存器、算东西的 ALU、发号施令的控制单元。难点不在认部件，而在判断一个控制信号发出后，数据能不能在规定的时钟内稳定到达目的地。这一章按“通路怎么走、控制怎么发、标志怎么来”三层往下拆。

3.1 单总线结构：为什么寄存器传送必须分步

单总线结构里，所有寄存器都挂在一组内总线上，同一时刻只允许一个源把数据放上总线、一个目的把数据取走。想完成R1 -> R2，需要两个控制信号：R1 的输出使能打开，把数据送上总线；R2 的输入使能打开，在时钟边沿锁存。两个信号可以在同一个时钟里有效，因为源和目的不冲突。

但R1 -> R2和R3 -> R4就不能同拍做，两条路径都要占用总线，硬件上直接冲突。习题里常给一段操作序列，问“最少需要几个时钟周期”，解法就是看每一步能不能合并：源不同、目的不同、且不经过 ALU 的，可以并到一拍；只要共用总线或者共用 ALU，就得拆开。

多总线结构用空间换时间。双总线允许两组传送并行，三总线可以让两个源同时送进 ALU 再把结果送回去，一拍完成加法。代价是芯片内部布线面积增加，寄存器端口数变多。这个取舍在教材里通常只用一句话带过，做题时却直接影响周期数计算，看到题目给的是单总线还是双总线，先确定下来再动手。

还有一种常见结构是单总线加暂存寄存器。ALU 的两个输入端如果都接总线，会出现“两个数同时要上总线”的矛盾，于是在 ALU 一侧加一个暂存器，先把一个操作数锁进去，再让另一个操作数上总线。题目问“执行一次加法需要几步”，答几步取决于暂存器在不在通路上，读图时要盯住 ALU 输入端的连线。

3.2 控制单元：硬布线与微程序的取舍

控制单元要解决的问题是：当前指令的操作码加上时序状态，应该发出哪一组控制信号。两种主流实现，硬布线和微程序，习题里经常要求比较。

硬布线控制用组合逻辑电路直接产生控制信号，输入是指令译码结果和时钟状态，输出是一堆使能信号。速度快，因为信号经过几级门电路就出来了；缺点是改一条指令就要改电路，不灵活。RISC 类设计偏爱这条路，指令少而规整，组合逻辑不难写。

微程序控制把控制信号存在控制存储器里，每条机器指令对应一段微程序，执行时逐条取出微指令，用微指令的各个位去驱动控制信号。灵活，改指令只需改控存内容；代价是多了一次控存访问，速度慢一些，而且微指令格式的设计本身就是一道题。

微指令编码有两种典型方式。水平型微指令一位控制一个信号，并行度高、微程序短、字长长；垂直型微指令把操作编码成字段，字长短、需要译码、微程序长。题目给出控存容量和控制信号数量，问采用哪种编码更省空间，本质是在算“字长 × 微指令条数”这个乘积，把两种方案的乘积都算出来比大小即可。

3.3 标志位：溢出和进位不是一回事

ALU 除了出结果，还要出标志。进位标志 C 记录最高位有没有向更高位进位，溢出标志 V 记录有符号数运算结果有没有超出表示范围，零标志 Z 记录结果是否全零，符号标志 S 取结果的最高位。四个标志里，C 和 V 最容易被混为一谈。

无符号数加法看 C，有符号数加法看 V。8 位补码里，1000_0000 + 1000_0000结果是0000_0000，最高位有进位，C 为 1，但两个负数相加得零，显然溢出，V 也为 1。而1111_1111 + 0000_0001结果是0000_0000，C 为 1，一个负数加一个正数不可能溢出，V 为 0。这两组数放在一起，就能看出 C 和 V 是两套判断。

硬件上，V 的常用判法是最高位进位与次高位进位异或。下面这段代码把两种判法都写出来，方便对照。

def alu_add(a, b, width=8): mask = (1 << width) - 1 raw = a + b result = raw & mask c_out = 1 if raw > mask else 0 # 最高位向上的进位 # 次高位向上的进位：只看低 width-1 位的和是否溢出 c_in = ((a & (mask >> 1)) + (b & (mask >> 1))) >> (width - 1) v = c_out ^ c_in # 溢出 = 两次进位不同 z = 1 if result == 0 else 0 s = (result >> (width - 1)) & 1 return result, c_out, v, z, s # 双符号位判溢出的等价写法 def overflow_by_dup_sign(a, b, width=8): sa = (a >> (width - 1)) & 1 sb = (b >> (width - 1)) & 1 sr = ((a + b) >> (width - 1)) & 1 return 1 if (sa == sb and sr != sa) else 0

width决定字长，改成 16 就是 16 位运算；mask用来截断，保证结果只保留低width位。c_in的算法先屏蔽最高位再求和，右移width - 1位取到的就是次高位向最高位的进位。函数最后的双符号位判法更直观：两个操作数符号相同、结果符号不同，就是溢出。两种判法在补码下等价，做题时哪种快用哪种，但要知道它们等价的原因，而不是死记。

4. 存储器层次与总线：命中率和带宽到底卡在哪一级

性能题里最常见的两类计算，一类围绕存储器层次，一类围绕总线。前者算平均访问时间，后者算带宽和传输时间。公式都不长，但参数一多就容易代错位置。这一章把局部性原理、三种地址映射和三组总线的物理含义串起来，说清每个参数在机器里对应哪根线、哪个部件。

4.1 局部性原理与 AMAT：命中率掉一个点值多少钱

存储器做成层次结构，靠的是程序访问的局部性。时间局部性指刚被访问过的单元很可能马上再被访问，循环变量是典型；空间局部性指刚被访问单元的邻近单元很可能被访问，顺序执行的指令和数组是典型。Cache 能起作用，全靠这两条性质，跟具体用什么替换算法关系反而没那么大。

平均访问时间 AMAT 是衡量层次效果的核心指标。如果每次访存都先查 Cache，命中就直接返回，缺失再去主存取，那么 AMAT 等于命中时间加上缺失率乘以缺失代价。如果缺失时 Cache 和主存要串行访问两次，公式里还要把命中时间再加一遍。这两种口径在不同的教材和题目里都出现过，做题前先看题目描述的是哪一种。

def amat_parallel(hit_time, miss_rate, miss_penalty): # 命中与缺失二选一：缺失时只计主存时间 return hit_time + miss_rate * miss_penalty def amat_serial(hit_time, miss_rate, miss_penalty): # 缺失时先查 Cache 再访主存：两段时间都要算 return hit_time + miss_rate * (hit_time + miss_penalty) Tc, Tm = 1.0, 60.0 # 单位 ns：Cache 访问时间、主存访问时间 for h in (0.90, 0.95, 0.99): mr = 1 - h print(h, round(amat_parallel(Tc, mr, Tm), 2), round(amat_serial(Tc, mr, Tm), 2))

这段输出很能说明问题：命中率从 0.95 提到 0.99，缺失率从 5% 降到 1%，AMAT 从 4 ns 左右掉到 1.6 ns 左右，收益远超直觉。反过来，命中率从 0.99 掉到 0.95，平均访问时间翻两倍多。这类题的“坑”在缺失代价的定义：如果主存时间 60 ns 里已经包含了 Cache 查询的那 1 ns，就不能再按串行口径加一遍，否则结果虚高。

4.2 地址映射：直接、全相联、组相联的比较器账

Cache 和主存之间的地址映射有三种。直接映射把主存块固定放到某一行，行号等于块号对行数取模，硬件最简单，只要一个比较器；缺点是冲突缺失严重，两个块号相差整数倍行数的地址会反复争同一行。全相联允许任意块放进任意行，冲突最少，但每访问一次要和所有行的标记并行比较，比较器数量和行数同阶，成本高。组相联折中，组间直接映射、组内全相联，比较器数量等于每组行数。

做题时经常给主存容量、块大小、Cache 容量，要求画地址划分。通用步骤是：块内地址位数等于 log2(块大小)；直接映射时行号位数等于 log2(Cache 行数)，剩下的是标记；组相联时先算组数等于 Cache 容量除以（块大小乘每组行数），组号位数等于 log2(组数)，剩下是标记。地址划分错了，后面算标记阵列容量、算比较器位数全跟着错。

替换算法只在组相联和全相联里有意义，直接映射没有选择余地，缺了就直接覆盖。FIFO、LRU、随机是三种常见策略，LRU 命中率通常最好，但需要为每行维护访问计数，硬件开销大。题目问“某种替换算法下命中次数”，本质是模拟一遍访问序列，把每行的状态手工推演，别指望套公式。

写策略也常考。写直达指每次写都同时写 Cache 和主存，实现简单，但总线流量大；写回指只写 Cache，置脏位，等该行被替换时再写回主存，流量小，但一致性维护复杂。多核场景下还有缓存一致性问题，那属于更上层的内容，基础题一般只考单核下的写策略对总线带宽的影响。

4.3 三组总线：地址线定空间，数据线定宽度

总线分三类。地址总线单向，由 CPU 或主设备发出，宽度直接决定可寻址空间，n 根地址线按字节编址就是 2 的 n 次方字节。数据总线双向，宽度决定一次能并行传输多少位，通常和机器字长、存储字长相关，但不一定相等。控制总线传读写信号、中断请求、总线请求、时钟等，方向因信号而异。

带宽计算是高频题。总线带宽等于总线宽度乘以总线频率，再除以每次传输占用的时钟数。如果题目说“每个总线周期传送一次数据，总线周期包含两个时钟”，就要除以 2。

def bus_bandwidth(width_byte, freq_hz, clocks_per_transfer=1): # 有效带宽，单位 B/s return width_byte * (freq_hz / clocks_per_transfer) def transfer_time(total_bytes, width_byte, freq_hz, clocks_per_transfer=1): bw = bus_bandwidth(width_byte, freq_hz, clocks_per_transfer) return total_bytes / bw # 32 位数据线、66 MHz、每个总线周期 2 个时钟 bw = bus_bandwidth(4, 66e6, 2) print(bw / 1e6, "MB/s") print(transfer_time(1024 * 1024, 4, 66e6, 2), "s")

width_byte是数据线宽度换算成字节，32 位就是 4 字节；freq_hz用赫兹，66 MHz 写成 66e6；clocks_per_transfer是每个传输周期占用的时钟数。这套参数改一改就能覆盖大多数总线题，关键是把“总线频率”和“时钟周期”的倒数关系记牢，别把 66 MHz 当成 66 纳秒。

地址线和数据线还会联合出题，比如“地址线 20 根、数据线 16 根，按字节编址，最大寻址空间是多少”。答案是 2 的 20 次方字节，即 1 MB，数据线宽度不影响寻址空间，只影响一次能读多少。这个点每年都有人答成 2 的 20 次方乘 2 字节，原因就是把“按字节编址”和“按字编址”搞混了。

5. 避坑排查：习题里翻车最多的五个地方

做了几十道题之后会发现，错的往往不是不会，而是某一步默认了错误的前提。下面五条是按题号翻解析时出现频率最高的翻车点，每条按现象、原因、解决三段写，对着自己的错题本核一遍，能省不少返工。

5.1 单位换算：KB 到底是 1000 还是 1024

现象：算 Cache 容量、算主存地址范围时，结果和答案差 2.4% 左右，或者差整整一倍。

原因：存储容量题里 KB、MB 有时按 1024 进，有时按 1000 进，取决于题目语境；而传输速率、总线带宽通常按 1000 进。频率和时间更是重灾区，1 GHz 的时钟周期是 1 ns，500 MHz 是 2 ns，有人把 500 MHz 当成 0.5 ns。

解决：做题前先在草稿上写一行换算约定，容量类统一按 2 的幂，速率类统一按 10 的幂，频率一律先换成周期再参与计算。遇到答案差 2.4%，八成是 1000 和 1024 混用；差一倍，八成是把周期和频率搞反了。

5.2 平均访问时间：缺失代价里含不含命中时间

现象：同一组参数，用两个公式算出两个答案，不知道哪个对。

原因：有的题目设定缺失时先查 Cache 再访主存，两段时间串行；有的设定缺失时直接访主存，Cache 查询被重叠掉。教材不同、题源不同，口径不一样。

解决：看题干里的动词。“先访问 Cache，未命中再访问主存”是串行口径，要把命中时间算两次；“Cache 未命中时直接从主存读取”是并行口径，只算一次。实在拿不准，就把两种结果都写出来，选和题目给的总时间量级吻合的那个。

5.3 CPI 与指令周期：两个“周期”不是一回事

现象：算 MIPS 时，把指令周期当成 CPI 代进去，结果大了几百倍。

原因：CPI 是平均每条指令消耗的时钟周期数，是无量纲的比值；指令周期是执行一条指令的绝对时间，单位是秒或纳秒。两者中间差一个时钟周期。

解决：先把时钟频率换成时钟周期，再用“指令周期等于 CPI 乘时钟周期”这条关系搭桥。MIPS 等于时钟频率除以（CPI 乘 10 的 6 次方），频率用赫兹。算完检查量纲，MIPS 的量级一般在几十到几千之间，出现几百万肯定是单位错了。

5.4 溢出判断：只看最高位进位

现象：补码加法题里，明明两个正数加出负数，却判成没溢出。

原因：把无符号数的进位标志当成了有符号数的溢出标志。最高位有进位只说明无符号结果超了，不说明有符号结果超了。

解决：有符号数用双符号位判，或者用最高位进位和次高位进位异或。做完随手验算：两个同号数相加，结果符号变了就是溢出；两个异号数相加，永远不会溢出。用这条性质反查，比盯公式快。

5.5 寻址空间：按字节编址还是按字编址

现象：地址线 20 根，答案给 1 MB，自己算出 512 KB 或 2 MB。

原因：没注意编址单位。按字节编址时，一个地址对应一个字节；按字编址时，一个地址对应一个字，寻址空间要按字长折算。

解决：先圈出题干里的“按字节编址”或“按字编址”，再确认字长是多少位。按字节编址，n 根地址线的空间就是 2 的 n 次方字节；按字编址，空间是 2 的 n 次方个字，换算成字节要乘字长字节数。数据线宽度不参与寻址空间计算，只影响一次传输的数据量。

6. 性能指标与设计取舍：CPI、MIPS 与 Amdahl 定律之间的相互矛盾

性能这块最容易产生的错觉，是以为指标越高机器就越快。CPI 低说明指令实现得简单，但可能指令条数多；主频高说明时钟周期短，但可能 CPI 被拉高；MIPS 只对同一套指令集、同一类程序有比较意义，跨指令集比 MIPS 基本等于耍花招。几个指标之间的关系可以列成一张表：

Amdahl 定律在这里的作用是泼冷水：如果程序里只有 40% 的部分能被加速，那么无论这部分加速到多快，整体加速比上限就是 1 除以 0.6，约 1.67 倍。习题里常给“某部件提速 10 倍，占比 20%，问总加速比”，代入公式算出来约 1.22 倍，很多人第一反应是 10 倍，就是把局部加速比当成了整体。真正值得记的不是公式本身，而是它逼你先问一句：这部分到底占多少。

设计取舍也在这。加深流水线能提高主频，但分支预测失败和访存停顿的代价会被放大；加大 Cache 能提高命中率，但访问时间变长，还可能挤占芯片面积；CISC 指令功能强、程序短，但译码复杂、难以流水；RISC 指令规整、易流水，但程序条数多、对编译器要求高。这些取舍没有标准答案，题目给的参数就是立场。

从那以后我每次做性能题，都强制先把“指令条数、CPI、时钟周期”三个量单独列出来，再动笔算任何一个比值，宁可多写一行也不省这一步。很多所谓的难题，卡住的地方根本不在公式，而在没分清哪个量是绝对的、哪个量是相对的。希望帮到你。

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