• 将 m 和 n 转换为十进制后相加：

  • m = 3×4² + 1×4¹ + 3×4⁰ = 3×16 + 1×4 + 3×1 = 48 + 4 + 3 = 55
  • n = 3×4² + 2×4¹ + 2×4⁰ = 3×16 + 2×4 + 2×1 = 48 + 8 + 2 = 58
  • m+n = 55 + 58 = 113（十进制）

• 将 113 转换为四进制：

  1. 113 ÷ 4 = 28 余 1
  2. 28 ÷ 4 = 7 余 0
  3. 7 ÷ 4 = 1 余 3
  4. 1 ÷ 4 = 0 余 1

因此，四进制表示为 (1301)₄。

IEEE 754 标准规定了以下位分配：

• 符号位：1 位
• 指数宽度：8 位
• 有效数字（尾数）：24 位（其中 23 位显式存储）

十进制的 0.5 对应二进制的 $1 \times 2^{-1}$。因此：

1. 指数值：偏移量为 127 的 IEEE 754 单精度浮点数中，实际指数值为 -1
2. 尾数位：由于二进制表示为 1.0（隐含前导 1），显式存储的 23 位尾数全为 0
3. 符号位：正数，故为 0

最终表示为：
0 11111110 00000000000000000000000
（符号位 | 指数域 | 尾数域）

解释：P = (F87B)₁₆ 对应的二进制为 -1111 1000 0111 1011。注意最高有效位为 1，说明该数为负数。对数值进行二进制补码运算可得 P = -1925，8P = -15400。由于 8P 仍为负数，需对其取补码：

• 15400 的二进制为 0011 1100 0010 1000
• 补码结果为 1100 0011 1101 1000 = (C3D8)₁₆

另一种方法：

• P = (F87B)₁₆ 的二进制为 1111 1000 0111 1011（最高位为 1 表示负数）
• 通过补码运算得 P = -1925
• 1925 的二进制为 0000 0111 1000 0101
• 8P 相当于将 P 左移 3 位得到 0011 1100 0010 1000
• 加上负号后变为 1011 1100 0010 1000
• 其补码为 1100 0011 1101 1000 = (C3D8)₁₆

解析：

1. 八进制转二进制 每位八进制数对应 3 位二进制数：

   1 → 001
   2 → 010
   1 → 001
   7 → 111
   

   合并后得到：(001 010 001 111)₂

2. 二进制转十六进制
   将二进制数从右向左每 4 位分组（不足补零）：
   (0010 1000 1111)₂
   对应十六进制：

   0010 → 2
   1000 → 8
   1111 → F
   

   最终结果为：(28F)₁₆，即选项 B

• IEEE 754 标准规定：当指数域和尾数域全部为零时，表示零值（Zero）
• 符号位决定正负：符号位为 0 表示正零（+0），为 1 表示负零（-0）
• 本题分析：题目未明确给出符号位，默认按 0 处理，因此对应特殊值 +0
• 关键区分：
  • 规格化值需满足指数域非全 0/全 1
  • 全 0 的指数域与尾数域组合属于特殊值范畴

由于数值为负，符号位 S 为 1
将 14.25 转换为二进制：1110.01
归一化为：1.11001 × 2³
偏移指数（加 127）：3 + 127 = 130（二进制为 10000010）
尾数：110010…..0（共 23 位）

IEEE 754 单精度格式表示为：
1 10000010 11001000000000000000000

按四比特分组转换为十六进制：
1100 0001 0110 0100 0000 0000 0000 0000

结果为：C1640000

此处我们有：

• A = 1111 1010 = -6₁₀（A 是二进制补码数）
• B = 0000 1010 = 10₁₀（B 是二进制补码数）

计算过程：

1. 十进制乘法：
   A × B = (-6) × 10 = -60₁₀

2. 转换为二进制补码：

   • 原码表示：1 011 1100₂（最高位为符号位）
   • 反码转换：1 100 0011₂
   • 补码结果：1 100 0100₂（8 位截断后为 1100 0100）

结论：
A 和 B 在二进制补码中的乘积是 1100 0100，即选项 A。
所以，A 是正确答案。

由于最高有效位为 1，所有数字均为负数。
除数（11111011）的二进制补码 = 反码 + 1 = 00000100 + 1 = 00000101
因此该数对应的十进制值为 -5

选项 A 的十进制值为 -25

解析：

• 最大差值条件：相邻两个数的最大差值出现在指数部分取最大值时。
• 指数字段分析：
  • 指数字段为 6 位（位置 14 至 9），其无偏最大值为 63。
  • 若采用偏置值 32（即实际指数为 e - 32），则最大有效指数为 63 - 32 = 31。
• 尾数字段分析：
  • 尾数字段为 9 位（位置 8 至 0）。
  • 相邻数的间隔为 2⁽³¹ ⁻ ⁹⁾ = 2²²。
• 结论：正确答案为选项 C。

解析：

• 第一步：0.25₁₀ × 2 = 0.50 → 整数部分为 0
• 第二步：0.50 × 2 = 1.00 → 整数部分为 1

通过连续乘以 2 取整数部分的方法，最终得到：
0.25₁₀ = 0.01₂
因此选项 B 正确。

解析步骤：

1. 原码表示：-15 的原码为 11111（最高位为符号位 1，其余 4 位表示数值 15）
2. 反码计算：符号位保持 1 不变，其余位取反 → 10000
3. 补码生成：反码基础上加 1 → 10000 + 1 = 10001

结论：最终补码结果为 10001，对应选项 D。

解析

• 溢出仅在符号位与最高有效位的进位不一致时发生
• 正负数相加不会导致溢出（因为结果绝对值一定小于任一操作数）

$-539_{10} = 1\ 010\ 0001\ 1011_2$（最高位的 1 表示负数）

• 原码转反码
  反码 = $1\ 101\ 1110\ 0100$

• 反码转补码
  补码 = $1\ 101\ 1110\ 0101$

• 补码转十六进制

  1101 1110 0101
   D    E    5
  

  最终结果为 DE5

因此，选项 C 是正确答案。

由于采用 32 位表示法，因此最大精度为 32 位。
当将 C（即 1.0）加到 A 时，相当于在 A 的第 31 位设置为 1，这显然超出了 A 的精度范围（注意是第 31 位而非第 31 个二进制位）。因此，该加法操作会直接返回 A 的原始值作为 Y 的赋值结果。
随后，Y + B 会抵消 A 的值，得到 0.0；而 X 初始为 A + B = 0.0，再加 C 后得到 1.0。

需要注意的是，2000 与 2×10³的表示方式存在差异。结果取决于数量级部分可用数字的数量，无法通过调整指数部分来弥补精度损失。
因此，选项 (B) 正确。此解释由 Piyush Doorwar 贡献。

解析：

• 十进制数 $ k $ 位转换为二进制时，位数约为 $ \frac{k}{\log_2(10)} \approx \frac{k}{3.32} $。
• 选项 (B) 中的 “k/2” 明显小于实际值，因此错误。
• 其他选项同样不符合数学规律，故正确答案为 D（以上都不对）。

解析

IEEE 754 转换过程如下：

1. 符号位
   数值为负 → 符号位 S = 1

2. 二进制转换
   -25.75 的绝对值转换为二进制：11001.11

3. 规范化表示
   移动小数点至规范形式：1.100111 × 2⁴
   指数部分：4 + 127 = 131（偏移量为 127）
   对应二进制指数：10000011

4. 尾数编码
   尾数部分取 23 位：10011100000000000000000

5. 最终二进制组合

   S    指数 (8 位)        尾数 (23 位)
   1  10000011  10011100000000000000000
   

6. 十六进制转换
   按 4 位分组：

   1100 0001 1100 1110 0000 0000 0000 0000
   

   对应十六进制：C1CE0000

• (i) 31.500 可以表示为：
  $(31.5)_{10} = (11111.100)2$
  $2^4 + 2^3 + 2^2 + 2^1 + 2^0 + 2^{-1} = 16 + 8 + 4 + 2 + 1 + 0.5 = (31.5){10}$

• (ii) 0.875 可以表示为：
  $(0.875)_{10} = (00000.111)2$
  $2^{-1} + 2^{-2} + 2^{-3} = 0.50 + 0.25 + 0.125 = (0.875){10}$

• (iii) 12.100 和 (iv) 3.001 无法表示。

  • (iii) 的小数部分 0.1 无法用有限二进制小数表示
  • (iv) 的小数部分 0.001 也无法用有限二进制小数表示

因此，选项 (C) 正确。更多信息请参阅。

& 是按位与运算符。
示例分析：

• 设 X = 2⁴ = 16 = 10000（二进制）
• 则 X - 1 = 15 = 01111（二进制）
• 此时 X & (X-1) = 00000

原理说明：
当 X 是 2 的幂时，其二进制形式为 100...0，减 1 后变为 011...1。按位与操作会逐位比较，只有全为 1 时结果才为 1，因此最终结果必为全 0。

因此，选项 (B) 正确。

精度可以理解为浮点数能够表示的最大准确性。
它是浮点表示中能够表示的最小变化量。单精度规范化数的小数部分恰好具有 23 位分辨率（加上隐含位后共 24 位）。

从十进制表示的角度来看：
设十进制有效数字位数为 $ x $，则满足关系式：

$$ 2^{-23} = 10^{-x} $$

取对数得：

$$ \log_2(10^{-x}) = -23 \ -x \log_2 10 = -23 \ -3.322x = -23 \ x = 6.92 $$

由于有效数字位数需向下取整，因此十进制精度为 7 位。
故正确答案是 (C)

解析过程：

• R1 = 0x42200000

  • 二进制表示：0100 0010 0010 0000 0000 0000 0000 0000
  • 符号位 S=0 → 正数
  • 阶码 (10000100)₂ = 132 → 真实阶码 = 132 - 127 = 5
  • 尾数 (010 000000000)₂ → 数值计算： $$ (-1)^0 \times (1.01000000000…) \times 2^5 = (101000.0)_2 = 40 $$

• R2 = 0xC1200000

  • 二进制表示：1100 0001 0010 0000 0000 0000 0000 0000
  • 符号位 S=1 → 负数
  • 阶码 (10000010)₂ = 130 → 真实阶码 = 130 - 127 = 3
  • 尾数 (010 000000000)₂ → 数值计算： $$ (-1)^1 \times (1.01000000000…) \times 2^3 = -(1010.0)_2 = -10 $$

• R3 = 40 / -10 = -4

  • IEEE-754 格式转换：
    • 符号位 S=1
    • 数值 $-4 = -1.0 \times 2^2$ → 真实阶码 = 2
    • 对应阶码 = 2 + 127 = 129 → (10000001)₂
    • 尾数全零
    • 最终二进制：1100 0000 1000 0000 0000 0000 0000 0000
    • 十六进制表示：0xC0800000

选项 B 正确。

已知：

• 符号位 = 1 → 数值为负
• 有偏指数位 = 10000001 = 129 → 实际指数 E = 129 - 127 = 2
• 尾数位 = 11110000000000000000000

数值计算过程：

• 二进制表示：–1.111100..00 × 2²
• 二进制展开：-111.11
• 十进制转换：
  • 整数部分：111₂ = 7₁₀
  • 小数部分：0.11₂ = 0.75₁₀
  • 合并结果：-7.75

因此，该数值的十进制形式为 -7.75。

溢出判定规则：

1. 带符号数（补码）：
   • 若两个正数相加结果为负 → 溢出
   • 若两个负数相加结果为正 → 溢出
2. 无符号数：
   • 最高位产生进位 → 溢出

具体分析：

• (i) 1100（-4）+ 1100（-4）= 11000（截断后为 1000，即 -8）→ 结果仍为负数，无溢出
• (ii) 0011（3）+ 0111（7）= 1010（-6）→ 正数相加得负数，溢出
• (iii) 1111（-1）+ 0111（7）= 0110（6）→ 负数与正数相加，结果在有效范围内，无溢出

综上，仅 (ii) 符合溢出条件，故选 B

• 补码表示范围：$-2^{(n-1)}$ 到 $2^{(n-1)} - 1$
• 原码表示范围：$-(2^{(n-1)} - 1)$ 到 $2^{(n-1)} - 1$

以 n=8 为例：
 • 补码可表示 -128 到 127（共 256 个不同值）
 • 原码可表示 -127 到 127（共 255 个不同值）

差值为 1 的原因在于：
 1. 原码存在两个零的表示（+0 和 -0）
 2. 补码仅有一个零的表示

• 选项 (A)：1010

  • 二进制补码计算：0101 + 1 = 0110
  • 补码结果与原数不同

• 选项 (B)：0101

  • 二进制补码计算：1010 + 1 = 1011
  • 补码结果与原数不同

• 选项 (C)：1000

  • 二进制补码计算：0111 + 1 = 1000
  • 补码结果与原数相同 ✅

• 选项 (D)：1001

  • 二进制补码计算：0110 + 1 = 0111
  • 补码结果与原数不同

因此，选项 (C) 是正确的。

IEEE-754 32 位浮点数表示采用移码（excess-127）格式：

• 最高位表示尾数符号位（0 表示正数）
• 接下来 8 位表示指数部分（移码）
• 最后 23 位表示尾数值

已知浮点数表示为：0 10000000 110 0000 0000 0000 0000 0000

1. 符号位：最高位为 0 → 尾数为正
2. 指数部分：10000000 对应十进制 $2^7 = 128$
   • 移码转实际指数：$128 - 127 = 1$
3. 尾数部分：隐含前导 1 的规范化形式
   • 二进制尾数：$1.110\ 0000\ 0000\ 0000\ 0000\ 0000_2$
4. 最终计算： $$ (1.11)_2 \times 2^1 = 1 + \frac{1}{2} + \frac{1}{4} = 1.75 \times 2 = 3.5 $$ 选项 (C) 正确。

原式 = 3×4096 + 15×256 + 5×16 + 3
= (2 + 1)×4096 + (8 + 4 + 2 + 1)×256 + (4 + 1)×16 + 2 + 1
= (2 + 1)×2¹² + (2³ + 2² + 2 + 1)×2⁸ + (2² + 1)×2⁴ + 2 + 1
= (2¹³ + 2¹²) + (2¹¹ + 2¹⁰ + 2⁹ + 2⁸) + (2⁶ + 2⁴) + 2 + 1

由于：

• $2^{13}$ 是 1 后面跟着 12 个 0
• $2^{12}$ 是 1 后面跟着 11 个 0
• $2^{11}$ 是 1 后面跟着 10 个 0
• $2^{10}$ 是 1 后面跟着 9 个 0
• $2^9$ 是 1 后面跟着 8 个 0
• $2^8$ 是 1 后面跟着 7 个 0
• $2^6$ 是 1 后面跟着 5 个 0
• $2^4$ 是 1 后面跟着 3 个 0
• $2^1$ 是 1 后面跟着 0 个 0

将这些二进制数相加时，每个 $2^n$ 在二进制中仅包含一个 1。
最终结果中 1 的个数为：
$2^{13}$ → 1 个
$2^{12}$ → 1 个
$2^{11}$ → 1 个
$2^{10}$ → 1 个
$2^9$ → 1 个
$2^8$ → 1 个
$2^6$ → 1 个
$2^4$ → 1 个
$2^1$ → 1 个
$2^0$ → 1 个

总计 10 个 1。因此选项 (C) 正确。

符号 - 绝对值仅用于符号约定（最高有效位为 1 表示负数，0 表示正数）。
主要区别在于使用反码相加时，首先进行二进制加法，然后添加一个循环进位值。但补码对零只有一个表示形式，且不需要处理进位值。
九的补码是将十进制数的每一位从 9 中减去得到的。与反码类似，九的补码也通过加法实现减法运算。

• 补码表示法对 0 具有唯一性（即只有正零），
• 而符号 - 绝对值、反码和九的补码对 0 的表示存在歧义（即同时存在正零和负零）。

因此，选项 (C) 正确。

在二进制编码十进制（BCD）编码方案中，每个十进制数字（0-9）都由其对应的 4 位二进制模式表示。

一个开关可以存储 1 位信息（0 表示关闭，1 表示开启），而每个 BCD 数字占用 4 位，因此 12 个开关可组成 12/4 = 3 个 BCD 数字。每个 BCD 数字的取值范围是 0 到 9（共 10 种可能）。

因此，12 个开关中不同可能的 BCD 数字数量为：
= 10 × 10 × 10 = 1000 = 10³
所以选项 (D) 正确。

IEEE-754 双精度格式表示浮点数的长度为 64 位。
其组成结构如下：

• 符号位：1 位
• 指数位：11 位
• 尾数（小数）部分：52 位
  因此，选项 (D) 正确。

设该进制为 ‘x’。

$$ (1102)_3 = (123)_x = 1 \times 3^3 + 1 \times 3^2 + 0 \times 3^1 + 2 \times 3^0 = 1 \times x^2 + 2 \times x + 3 $$

$$ = 27 + 9 + 0 + 2 = x^2 + 2x + 3 $$

$$ \Rightarrow x^2 + 2x - 35 = 0 $$

$$ \Rightarrow x = 5 \quad (\text{舍去负解}) $$

正确选项是 (B)

(42.75)₁₀ = (?)₂

• 整数部分：
  32 16 8 4 2 1
  1 0 1 0 1 0
• 小数部分：
  0.75 × 2 = 1.5 → 取整 1
  0.5 × 2 = 1.0 → 取整 1
  0.0 × 2 = 0.0 → 取整 0
  得到 0.110
  选项 (A) 正确

浮点数的十六进制表示 = C1D00000
浮点数的二进制表示 = 1100 0001 1101 0000 0000 0000 0000 0000
在 32 位单精度 IEEE 浮点表示中，最高位表示尾数符号：1 表示负数，0 表示正数。接下来 8 位是指数部分，最后 23 位是尾数部分。

指数值 = 131 - 127 = 4
尾数 = -1.101000000...0

浮点数值 = -1.10100…0000 × 2⁴ = -11010
= -26

解析：

1. 指数范围分析
   8 位二进制补码表示的指数范围为 $[-128, 127]$，因此最大正指数为 $10^{127}$。

2. 尾数范围分析
   16 位尾数（二进制补码）能表示的最大正数为 $2^{15} - 1$，而非 $2^{15}$（因最高位为符号位）。

3. 组合计算

   • 最小正数：当尾数为 $1$（最小非零值），指数为 $-128$ 时，结果为 $1 \times 10^{-128}$。
   • 最大正数：当尾数为 $2^{15} - 1$，指数为 $127$ 时，结果为 $(2^{15} - 1) \times 10^{127}$。

4. 选项排除

   • A/B/C 中的 $2^{15}$ 或 $10^{255}$ 均不符合实际尾数/指数范围。
   • D 项精确匹配上述推导结果。

1. 计算缓存行数
   行数 = 缓存大小 / 块大小 = 2¹¹ B / 2⁶ B = 2⁵

2. 确定组号位数
   地址总位数 = 32 位
   标记位 = 22 位
   偏移量位 = log₂(块大小) = 6 位
   组号位 = 32 - 22 - 6 = 4 位

3. 计算组数
   组数 = 2^{组号位} = 2⁴ = 16

4. 求解关联度
   关联度 = 行数 / 组数 = 2⁵ / 2⁴ = 2

S1 分析

• 直写（Write Through）特性决定了所有写操作会同步传播到 L2 缓存
• 因此 L1 缓存中 不存在脏行（Dirty Line）
• 读缺失（Read Miss）时无需执行脏行写回操作
• 结论：S1 成立

S2 分析

• 直写缓存通常采用 不写分配（No-Write Allocate）策略
  • 直接通过 L1 向 L2 传递写操作，无需加载数据到 L1
• 写回缓存通常采用 写分配（Write Allocate）策略
  • 数据逐出 L1 时才会更新 L2 中的副本
• 原命题 “写分配必须与直写配合” 是错误表述
• 结论：S2 错误

最终结论：S1 正确，S2 错误，正确答案为 A

解析：

• 缓存中共有 v 个组
• 主存块 j 将被映射到第 (j mod v) 个组中
• 该组对应的缓存行范围是：
  (j mod v) × k 至 (j mod v) × k + (k-1)

解析过程

1. 芯片数量计算

   • 目标容量：16K × 16
   • 单芯片容量：1K × 8
   • 所需芯片总数： $$ \frac{16K \times 16}{1K \times 8} = \frac{16 \times 16}{1 \times 8} = 32 \text{ 片} $$
   • 分布方式：
     • 垂直方向（地址扩展）：16 片（16K / 1K）
     • 水平方向（数据扩展）：2 片（16 位 / 8 位）

2. 译码器需求分析

   • 需要选择 16 片中的某一片 → 需 4:16 译码器
   • 可用译码器为 2:4 译码器，需通过级联实现 4:16 功能

3. 译码器级联逻辑

   • 第一级：1 个 2:4 译码器（控制 4 组）
   • 每组需 4 个 2:4 译码器（实现 4:16 的子译码）
   • 总计：$1 + 4 = 5$ 个 2:4 译码器

结论：需 5 个 2:4 译码器 实现 4:16 译码功能。

组相联方案是全相联缓存和直接映射缓存之间的折中方案。它在需要全相联缓存（需并行搜索所有槽位）复杂硬件与直接映射方案（可能导致相同槽位地址冲突，类似哈希表冲突）之间取得了合理平衡。

• 块数量计算
  块数量 = 缓存大小 ÷ 块大小 = 256 KB ÷ 32 字节 = 2¹³

• 组数量计算
  组数量 = 块数量 ÷ 路数 = 2¹³ ÷ 4 = 2¹¹

• 地址字段分解
  地址总位数 = 标签 + 组偏移 + 字节偏移
  32 = 标签 + 11 (组偏移) + 5 (字节偏移)
  解得：标签 = 16

• 地址位：16 位
• 有效位：2 位
• 修改位：1 位
• 替换位：1 位

总位数 = 16 + 2 + 1 + 1 = 20 位
总大小 = 20 位 × 块数量 = 160 Kbits

• 缓存参数

  • 缓存大小 = 8 KB
  • 块大小 = 32 字节
  • 行数量 = $ \frac{8 \times 1024}{32} = 256 $

• 地址分解

  • 地址总位数：32 位
  • 块内偏移量：$ \log_2(32) = 5 $ 位
  • 索引位数：$ \log_2(256) = 8 $ 位
  • 标签位数：$ 32 - 5 - 8 = 19 $ 位

• 元数据计算

  • 每行元数据位数：1（有效位） + 1（修改位） + 19（标签） = 21 位
  • 总内存：$ 21 \times 256 = 5376 $ 位

构建 4MB 主存所需的芯片数量 = (4 × 2²⁰ × 8) / (1 × 2²⁰) = 32 片
在一次刷新周期中，内存芯片的整行会被同时刷新。这意味着给定的 100ns 单次刷新时间仅刷新芯片的一行。由于共有 1K=2¹⁰行，因此刷新整个芯片需要：2¹⁰ × 100ns。

关键分析步骤：

1. 芯片数量计算

   • 主存总容量需求：4MB = 4 × 2²⁰ × 8 bit
   • 单个芯片容量：1M × 1 bit = 1 × 2²⁰ bit
   • 所需芯片数：(4 × 2²⁰ × 8) ÷ (1 × 2²⁰) = 32 片

2. 刷新机制特性

   • 行刷新原理：DRAM 刷新以行为单位，单次刷新操作可完成一行内所有存储单元的刷新。
   • 单芯片刷新时间：1K 行 × 100ns/行 = 2¹⁰ × 100ns

3. 芯片排列与并行性

   • 串联排列模式：32 片 1M×1bit 芯片串联组成 1M×32bit 的存储模块。
   • 并行刷新特性：所有串联芯片的同名行可在同一刷新周期内同步刷新。

结论：

• 总刷新时间 = 单芯片刷新时间 = 100 × 2¹⁰ ns
• 选项 (B) 正确。

解析

• 访问 L2 缓存的时间：20 ns
• 将数据写入 L1 缓存的时间：2 ns

由于 L1 缓存的块大小为 4 字，仅需完成一次数据迁移操作。
总时间 = 访问 L2 时间 + 写入 L1 时间 = 20 + 2 = 22 ns

解析

由于 L2 缓存的块大小为 16 字，而 主存→L2 缓存的传输速率为 4 字，因此需要进行四次每次传输 4 字的操作，然后再从 L2 缓存向 L1 缓存传输所需的 4 字。

具体计算如下：

• 主存→L2 缓存传输：4 次 × (200 ns + 20 ns) = 4 × 220 ns = 880 ns
• L2→L1 缓存传输：1 次 × (20 ns + 2 ns) = 1 × 22 ns = 22 ns

总时间：880 ns + 22 ns = 902 ns

选项 (C) 正确。

解析

• 目标容量：256 KB = 256 × 1024 × 8 比特
• 单个芯片容量：32 K×1 = 32 × 1024 比特
• 计算公式： $$ \frac{256 \times 1024 \times 8}{32 \times 1024} = 64 $$ 因此需要 64 片 32K×1 的 RAM 芯片。

解释：

• 陈述 I 不必要
  因为在同一时间点，数据不需要完全相同。因此也可以使用写回策略。

• 陈述 II 不必要
  因为讨论范围仅限于 L1 和 L2。

• 陈述 III 不必要
  因为关联度可以相等。

• 陈述 IV 是必要的
  L2 缓存必须至少与 L1 缓存一样大。

因此，选项 (A) 正确。

解析

1. 计算缓存参数

   • 缓存总容量：64 KB = 65536 字节
   • 块大小：16 字节 → 每块包含 16/8 = 2 个 double 元素
   • 组数：64 KB / (16 字节 × 2 路) = 2048 组

2. 确定标签位数

   • 虚拟地址 32 位，页面大小 4 KB = 4096 字节 → 页面内偏移量占 12 位
   • 块大小 16 字节 → 块内偏移量占 4 位
   • 组索引位数：log₂(2048 组) = 11 位
   • 标签位数 = 32 - 11 - 4 = 17 位

3. 计算标签总大小

   • 每组 2 路 → 总块数：2048 组 × 2 路 = 4096 块
   • 每块标签 17 位 → 总标签大小：4096 × 17 = 69632 位 = 68 Kbits

解释：缓存命中率 = 命中次数 / 总访问次数
      = 1024/(1024+1024)
      = 1/2 = 0.5 = 50%

因此，选项 (C) 是正确答案。

解析：

• 组数计算：128 行 ÷ 4 路 = 32 组
• 字偏移：64 字 → 需 $ \log_2{64} = 6 $ 位标识字位置
• 行偏移：32 组 → 需 $ \log_2{32} = 5 $ 位标识组索引
• TAG 计算：20 位地址 - (5 位行偏移 + 6 位字偏移) = 9 位 TAG

最终组合为：9 位 TAG, 5 位 LINE, 6 位 WORD

缓存大小 = $32 \times 64$ B = $2^{11}$ B = 2048 B，字节数组大小 = 2500 B，因此 cache 容量不足以容纳整个数组。

完整存储数组需要用到 $\lceil 2500 / 64 \rceil = 40$ 个 cache 行。在两次遍历数组的过程中，前 8 个 cache 行会在遍历过程被替换，后 24 个 cache 行不会被替换，所以 cache 缺失的次数为 $40 + 8×2 = 56$。

其中 40 为第一次遍历数组的 cache 缺失次数，8×2 为第二次遍历数组的缺失次数。

上一题我们已经提到，存储有数组的前八个 cache 行会被替换，所以这里关键就在于搞清楚第一个存储数组的 cahce 行号。

给 cache 的地址结构为：| 标记 (5 bits) | cache 行号 (5 bits) | 块内偏移 (6 bits) |

数组的起始地址 1100H 对应的二进制为 00010 00100 000000，对应的 cache 行号为 4，所以数组的第一个字节存储在 cache 的第 4 行。

前 8 个 cache 行会被替换，所以被替换的 cache 行为 4 到 11。

在 k 路组相联映射中，高速缓存被划分为若干组，每组包含 k 个块。
高速缓存容量 = 16 KB。
由于是四路组相联，K = 4。
块大小 B = 8 字（1 字=4 字节）。
物理地址空间大小 = 4 GB = 4×2³⁰ 字节 = 2³² 字节。

计算步骤：

1. 高速缓存总块数 N = 容量 / 块大小 = (16×1024 字节) / (8×4 字节) = 512
2. 组数 S = 总块数 / 每组块数 = 512 / 4 = 128
3. 物理地址空间划分：每个组可访问 (2³² 字节)/128 = 2²⁵ 字节 = 2²³ 字 = 2²⁰ 块
4. 为标识这 2²⁰ 个块，需要 20 位标记字段

因此选项 C 正确。

解析

块：内存被划分为等长的段，每个段称为一个块。缓存中的数据以块的形式存储。其核心思想是利用空间局部性（一旦某个位置被访问，很可能在不久的将来需要访问其附近的地址）。

标签位：每个缓存块都有一组标签位，用于标识该缓存块对应主内存中的哪个块。

• 选项 A：如果块大小较小，该块中包含未来 CPU 访问的附近地址的数量会减少，因此空间局部性并不更好。
• 选项 B：如果块大小较小，缓存中块的数量会更多，因此需要更多的缓存标签位，而不是更少。
• 选项 C：缓存标签位更多（因为较小的块大小导致更多块），但更多的标签位无法降低命中时间（甚至可能增加）。
• 选项 D：当缓存发生未命中（即 CPU 需要的块不在缓存中）时，必须从下一级存储（如主存）将该块调入缓存。若块大小较小，则调入缓存所需时间更短，因此未命中开销更低。

因此，正确答案是 D。

解析

• 关键结论：当缓存关联度加倍时，主存数据总线宽度（D） 是唯一不受影响的组件
• 各选项分析：
  • (B) 错误：关联度加倍导致组数减半 → 组索引位宽减少 → 解码器宽度必然变化
  • (C) 错误：每组包含的缓存行数量翻倍 → 需从双倍候选路径中选择 → 多路复用器宽度需增加
  • (A) 错误：组内条目数增加 → 需更多标记位区分不同映射 → 标记比较器宽度需扩展
  • (D) 正确：数据总线宽度由主存接口设计决定，与缓存组织方式（如关联度）无直接关联
• 核心原理：缓存架构变更（如关联度调整）主要影响控制器内部逻辑单元，而物理层的数据传输通道（如主存总线）属于独立设计维度，二者互不干扰

解析：

1. 参数定义

   • 缓存块大小：64 字节
   • 存储体数量 $ k = 24 $
   • 单个存储体宽度 $ c = 2 $ 字节

2. 单次迭代数据量
   每次并行访问可获取 $ k \times c = 24 \times 2 = 48 $ 字节。

3. 迭代次数计算
   获取 64 字节需 $ \lceil 64 / 48 \rceil = 2 $ 次迭代。

4. 单次迭代耗时

   • 解码时间：$ k/2 = 24/2 = 12 $ 纳秒
   • 存储体访问延迟：80 纳秒
   • 总单次迭代时间：$ 12 + 80 = 92 $ 纳秒

5. 总延迟
   $ 2 \times 92 = 184 $ 纳秒

解析过程：

1. 基础参数计算

   • 缓存大小 = 32 KB = 32 × 2¹⁰ 字节
   • 块大小 = 32 字节
   • 块总数 = 2

2. 组相联结构分析

   • 总组合数 = 缓存大小 / (块数 × 块大小) = 32 × 2¹⁰ / (2 × 32) = 512 = 2⁹
   • 索引位数 = log₂(512) = 9 位
   • 偏移位数 = log₂(32) = 5 位（因块大小为 32 字节）
   • 标签位数 = 32 – 9 – 5 = 18 位

3. 命中延迟计算

   • 多路复用器延迟 = 0.6 ns
   • 标签比较器延迟 = 18 / 10 = 1.8 ns
   • 总命中延迟 h1 = 0.6 + 1.8 = 2.4 ns

因此选项 (A) 正确。

解析：

• 缓存参数计算

  • 缓存大小 = 32 KB = 32 × 2¹⁰ 字节
  • 块大小 = 32 字节
  • 每组块数 = 2
  • 总组数 = 缓存大小 / (每组块数 × 块大小) = 32 × 2¹⁰ / (2 × 32) = 512 = 2⁹
  • 索引位数 = log₂(总组数) = 9 位
  • 偏移位数 = log₂(块大小) = log₂(32) = 5 位
  • 标签位数 = 地址总位数 - 索引位数 - 偏移位数 = 32 - 9 - 5 = 18 位

• 命中延迟计算

  • 多路复用器延迟 = 0.6 ns
  • 标签比较器延迟 = 18 / 10 = 1.8 ns
  • 总命中延迟 h1 = 多路复用器延迟 + 标签比较器延迟 = 0.6 + 1.8 = 2.4 ns

因此，选项 (A) 正确。

解析

• 访问模式分析

  • [P1] 采用行优先访问（A[i][j]）
  • [P2] 采用列优先访问（A[j][i]）

• 缓存参数计算

  • 缓存块数量 = 总容量 ÷ 块大小 = 32 KB ÷ 128 B = 256
  • 每块可容纳元素数 = 块大小 ÷ 元素大小 = 128 B ÷ 8 B = 16

• 未命中次数推导

  • 数组总元素数 = 512 × 512 = 262,144
  • 行优先访问时，每块可提供 16 次有效访问
  • 由于缓存容量限制，需替换的块数 = 总元素数 ÷ (每块元素数 × 缓存块数) = 262,144 ÷ (16 × 256) = 64
  • 实际未命中次数 = 每块首次访问触发一次未命中 → 64 × 256 = 16,384

• 关键结论 $$ M1 = \frac{512 \times 512 \times 16}{256} = 16384 $$

解析过程：

• 访问模式分析

  • 代码段 P1: 行优先访问（A[i][j]）
  • 代码段 P2: 列优先访问（A[j][i]）

• 缓存参数计算

  • 缓存块数量 = 缓存大小 ÷ 块大小 = 32KB ÷ 128 字节 = 256
  • 每个块中的数组元素数 = 块大小 ÷ 元素大小 = 128 字节 ÷ 8 字节 = 16

• 未命中次数计算

  • P1 总未命中次数 $$ \text{总元素数} \div \text{每块元素数} \times \text{缓存块数量} = (512 \times 512) \div 16 \times 256 = 16384 $$
  • P2 总未命中次数
    所有元素均未命中： $$ 512 \times 512 = 262144 $$

• 比例计算 $$ \frac{M1}{M2} = \frac{16384}{262144} = \frac{1}{16} $$

解析

• 缓存大小 = 32 KB = 2⁵ × 2¹⁰ 字节 = 2¹⁵ 字节
• 需要 15 位进行缓存寻址，因此 CPU 地址包含标记和索引
• 标记位数 = 32 - 15 = 17

从 15 位缓存寻址位中包含块和字（字节）：

• 每个块有 32 字节 → 需要 5 位偏移量
• 索引 = 块 + 字偏移
• 块位数 = 15 - 5 = 10

结论：索引位 10 位，标记位 17 位，选项 (A) 正确。

解释：

1. 总地址空间：32 位（对应 $2^{32}$ 字节内存）
2. 块内偏移（WO）：5 位（32 字节块，$\log_2{32} = 5$）
3. 组索引（SO）： $$ \log_2\left(\frac{\text{缓存行总数}}{\text{每组路数}}\right) = \log_2\left(\frac{512}{2}\right) = \log_2{256} = 8 \text{ 位} $$
4. 标记位计算： $$ 32 \text{（地址位）} - 8 \text{（组索引）} - 5 \text{（块内偏移）} = 19 \text{ 位} $$ 因此，选项 (C) 正确。

解析

• 核心原理：交换空间是操作系统在物理内存（RAM）不足时，用于临时存储数据的磁盘区域
• 定位依据：
  • 实际位置在磁盘（选项 B）
  • ROM 属于只读存储器
  • 片上缓存为高速缓存设备
• 功能限制：
  • ROM 和片上缓存不具备动态数据交换能力
  • 无法作为交换空间使用

解析

• 块大小 = 16 字节 → 块偏移 = 4
• 缓存行数 = 2¹² → 索引位数 = 12
• 主存大小 = 2²⁰ → 标签位数 = 20 - 12 - 4 = 4
• 十六进制地址 E201F 分解：

标签字段 = 前 4 位 = E（十六进制）
缓存行号 = 接下来的 12 位 = 201（十六进制）

解析

系统访问流程

系统会按层级依次查找缓存：

1. 首先查找一级缓存
2. 若一级缓存未命中，则查找二级缓存
3. 若二级缓存仍未命中，则访问主存

平均访问时间构成

需综合考虑以下三种场景：

• 一级缓存命中
• 一级缓存未命中但二级缓存命中
• 两级缓存均未命中且主存命中

计算公式

$$ \text{平均访问时间} = [H₁×T₁] + [(1-H₁)×H₂×T₂] + [(1-H₁)(1-H₂)×Hₘ×Tₘ] $$

分步计算

1. 一级缓存命中贡献：
   $ 0.8 × 1 = 0.8 \text{ns} $

2. 一级未命中但二级命中的贡献：
   $ (1-0.8) × 0.9 × 10 = 0.2 × 0.9 × 10 = 1.8 \text{ns} $

3. 两级未命中访问主存的贡献：
   $ (1-0.8)(1-0.9) × 1 × 500 = 0.2 × 0.1 × 500 = 10 \text{ns} $

最终结果

$$ \text{总平均访问时间} = 0.8 + 1.8 + 10 = \mathbf{12.6 \text{ns}} $$

因此，正确答案是选项 C。

解析：

• 已知条件：

  • 存储周期时间 = $64\text{ns} = 64 \times 10^{-9}\text{s}$
  • 刷新频率 = 每 $1\text{ms} = 10^{-3}\text{s}$ 刷新 100 次
  • 单次刷新耗时 = $100\text{ns} = 100 \times 10^{-9}\text{s}$

• 计算单个存储周期内的刷新次数：

  $$ \frac{100\text{次}}{10^{-3}\text{s}} \times 64 \times 10^{-9}\text{s} = 64 \times 10^{-4}\text{次} $$

• 计算总刷新耗时：

  $$ 64 \times 10^{-4}\text{次} \times 100 \times 10^{-9}\text{s/次} = 64 \times 10^{-11}\text{s} $$

• 计算刷新占用的存储周期百分比： $$ \frac{64 \times 10^{-11}\text{s}}{64 \times 10^{-9}\text{s}} \times 100% = 1% $$

因此选项 (C) 正确。若发现上述内容有任何错误，请在下方评论。

解析

• 最大内存容量：$4\text{GB} = 2^{32}\text{字节}$
• 每个字大小：$2\text{字节}$
• 因此，字的数量为：$\frac{2^{32}}{2} = 2^{31}$
• 所以处理器的地址总线需要至少 31 位
  因此，正确答案是 B。

解题思路

1. 基本公式
   物理地址 = 标记位 (T) + 组索引位 (S) + 块内偏移位 (O)
   即 $ T + S + O = 40 $

2. 参数计算

   • 高速缓存总容量：512 KB = $ 2^{19} $ 字节
   • 8 路组相联 → 每组包含 8 行
   • 设块大小为 $ 2^y $ 字节 → 块内偏移 $ O = y $ 位
   • 总行数 = $ \frac{512 \text{ KB}}{2^y} = \frac{2^{19}}{2^y} $
   • 组数 = $ \frac{\text{总行数}}{8} = \frac{2^{19-y}}{2^3} = 2^{16-y} $
   • 组索引位 $ S = \log_2(\text{组数}) = 16 - y $

3. 代入求解
   将 $ S = 16 - y $ 和 $ O = y $ 代入公式： $$ T + (16 - y) + y = 40 \Rightarrow T = 24 $$

错误分析与修正

原文第二种解释存在以下问题：

• 错误 1：行大小计算错误
  “行大小 = 512/8 = 64 KB” 是错误的，实际应为： $$ \text{块大小} = \frac{512 \text{ KB}}{8 \times \text{组数}} = \frac{2^{19}}{8 \times 2^x} = 2^{16-x} \text{ 字节} $$
• 错误 2：偏移位计算矛盾
  正确的偏移位应为 $ O = \log_2(\text{块大小}) = 16 - x $，而非文中所述的 6 位。

最终结论

通过规范推导可得：

$$ \text{标记位} = 40 - (S + O) = 40 - 16 = 24 \text{ 位} $$

此结果与选项 A 完全一致。

设 $x$ 为未命中率，则 $(1 - x)$ 为命中率。

• 命中时延迟为 1ms
• 未命中时延迟为 10ms

平均读取延迟计算如下：

$$ \text{平均时间} = x \times 10\text{ms} + (1 - x) \times 1\text{ms} = 9x + 1\text{ms} $$

根据题目要求，需满足：

$$ 9x + 1 < 6 \quad \Rightarrow \quad 9x < 5 \quad \Rightarrow \quad x < 0.5556 $$

由缺失率曲线可知：

• 20MB 缓存时缺失率为 60%（$x=0.6$）
• 30MB 缓存时缺失率为 40%（$x=0.4$）

因此，满足 $x < 0.5556$ 的最小缓存大小为 30MB。

• 带宽计算：1GB/秒 = $10^9$ 字节/秒
  • 加载 64 字节所需时间：$\frac{64}{10^9} \text{s} = 64 \text{ns}$
• 总时间计算：
  • 主存延迟 32ns + 数据传输时间 64ns = 96ns

解释

• 缓存中的块数 = 容量 / 块大小 = 2ᵐ
• 表示块所需的位数 = m
• 每个块中的字数 = 2ⁿ 字
• 表示字所需的位数 = n
• 标记位数 = （字的物理地址长度） - （表示块所需的位数） - （表示字所需的位数）
• 总标记位数 = 块数 × 标记位数

每个块都有自己的标记位。因此总标记位数 = 块数 × 标记位数。

根据题目描述可知
缓存总容量：8KB
主存总容量：1MB
块大小：128 字（128 字节）

计算步骤：

1. 缓存块总数
   缓存大小 ÷ (块大小 × 每字字节数) = 8KB ÷ (128 × 1B) = 64 块

2. 缓存组数
   四路组相联结构 → 组数 = 总块数 ÷ 4 = 64 ÷ 4 = 16 组
   SET 位数 = log₂(16) = 4 位

3. TAG 位数

   • 主存地址空间：1MB = 2²⁰ B
   • 每组对应主存区域大小：1MB ÷ 16 组 = 64KB = 2¹⁶ B
   • 每组包含的块数：2¹⁶ B ÷ 128 B/块 = 512 块
   • 需要 TAG 位数：log₂(512) = 9 位

4. WORD 位数
   块内偏移量：128 字 = 2⁷ → 需要 7 位

最终结论：
(TAG, SET, WORD) = (9, 4, 7)

• TAG 字段需要 9 位
• SET 需要 4 位，WORD 需要 7 位

根据上一题推导出的结论：
内存地址 0C795H 的二进制表示为：
0000 1100 0111 1001 0101

按字段划分：

• TAG = 前 9 位：0000 1100 0
• SET = 中间 4 位：1111
• WORD = 最后 7 位：001 0101

因此，匹配的选项是 选项 A。
该解法由 Namita Singh 贡献。

B
解析：

• 已知条件：

  • 主存 = 2 C M 块
  • 缓存大小 = 2 C 块

• 组相联映射规则：

  • 每组包含 2 条块（即 2 路组相联）
  • 每组的行数 = 2（组大小）

• 缓存组数计算：

  缓存组数 = 缓存大小 / 组大小
           = 2 C / 2
           = C
  

• 主存块映射规则：

  • 主存第 k 块映射到缓存的第 (k mod C) 组
  • 即：i = k mod c
    • i：缓存组号
    • k：主存块号
    • c：缓存中的组数

此解法由 VIVEK YEMUL 提供。

解析：

• 缓存块容量：16 字块 × 4 字/元素 = 可容纳 4 个元素
• 访问模式：每个元素被引用两次（一次读操作 + 一次写操作）
• 首次访问：第一个元素读取时发生缺失 → 整个块加载到缓存
• 后续访问：该块内后续 3 个元素的 7 次访问（含读写）均为命中
• 命中率计算：每 8 次访问中有 7 次命中 → 命中率 7/8
• 缺失率结论：1 - 7/8 = 1/8 = 0.125

选项 (D) 是正确的。

解析

• 关键公式：

  $$ \text{组偏移} = \frac{\text{行偏移}}{\log(\text{组数})} $$

  $$ \Rightarrow \text{行偏移} = \text{组偏移} \times \log(\text{组数}) $$

• 核心逻辑：
  将 16 路组相联缓存转为直接映射缓存时，标记位数需减少 $\log(\text{组数})$。

• 具体计算：

  $$ \text{新标记位数} = 10 - \log_2(16) = 10 - 4 = 6 $$

• 结论：
  选项 (A) 正确。

由于 L2 缓存同时服务于指令和数据。

• 平均指令获取时间 = L1 访问时间 + L1 缺失率 × L2 访问时间 + L1 缺失率 × L2 缺失率 × 内存访问时间
  = 2 + 0.2 × 8 + 0.2 × 0.1 × 90
  = 5.4 ns

• 平均数据获取时间 = L1 访问时间 + L1 缺失率 × L2 访问时间 + L1 缺失率 × L2 缺失率 × 内存访问时间
  = 2 + 0.1 × 8 + 0.1 × 0.1 × 90
  = 3.7 ns

因此，平均数据获取时间与平均指令获取时间的乘积总值为：5.4 × 3.7 = 19.98

选项 (D) 正确。

已知这是一个总共有 16 个缓存块的 4 路组相联缓存（初始为空），因此可以形成编号为 0 到 3 的 4 个组。每个组包含 4 个块。

给定的内存块对 4 取模后得到：0, 1, 0, 3, 0, 1, 3, 1, 3, 0, 0, 0, 1, 3。

• 第 0 组

  • 请求序列：{0, 4, 8, 8, 48, 32}
  • 命中分析：
    • 第一次访问 0 → 缺页
    • 第一次访问 4 → 缺页
    • 第一次访问 8 → 缺页
    • 第二次访问 8 → 命中
    • 后续访问 48/32 → 缺页

• 第 1 组

  • 请求序列：{1, 133, 129, 73}
  • 所有访问均为首次 → 全部缺页

• 第 2 组

  • 无请求 → 无命中

• 第 3 组

  • 请求序列：{3, 159, 63, 155}
  • 所有访问均为首次 → 全部缺页

最终仅发生 1 次命中，对应选项 (B) 正确。

物理地址空间为 $2^P$ 字节。字长为 $2^W$ 字节，意味着每个字的大小为 $2^W$ 字节。高速缓存容量为 $2^N$ 字节，标记字段大小为 $2^X$ 字节。

关键推导步骤：

1. 物理地址位数：
   按字寻址时，总字数为 $\frac{2^P}{2^W} = 2^{P-W}$，故物理地址需 $P - W$ 位。

2. 高速缓存块数：
   每个块大小为 $2^M$ 字 × $2^W$ 字节/字 = $2^{M+W}$ 字节。
   总块数为 $\frac{2^N}{2^{M+W}} = 2^{N-M-W}$。

3. 组数与组索引位数：
   K 路组相联下，组数为 $\frac{2^{N-M-W}}{K}$。
   组索引位数为 $\log_2\left(\frac{2^{N-M-W}}{K}\right) = N - M - W - \log_2 K$。

4. 偏移量位数：
   块内偏移量需 $M$ 位（因块大小为 $2^M$ 字）。

5. 标记位数计算：
   标记位数 = 物理地址位数 - 组索引位数 - 偏移量位数 $$ x = (P - W) - (N - M - W - \log_2 K) - M = P - N + \log_2 K $$

综上，选项 (B) 正确。

• 偏移字段（块大小）：8 字 × 每个字的大小 = 8 × 4 字节 = 32 字节
• 块数量：高速缓存大小 / 块大小 = 16 KB / 32 B = 512
• 组数量：512 / 2 = 256
• SET 字段所需位数：log₂(256) = 8 位
• TAG 位数：32 - 5 - 8 = 19 位

• 块大小与元素数量计算

  • 块大小 = 128 字节
  • 每块包含元素数 = 128 / 8 = 16

• 数组存储方式

  • 块 0：A[0][0] 到 A[0][15]
  • 块 1：A[0][16] 到 A[0][31] 依此类推

• i=0 时的缺失分析

  • A[0][0] 不在高速缓存中，发生缺失
  • 后续 15 个元素（j=1 到 j=15）命中缓存
  • j 从 0 到 512 循环时，每 16 个元素发生一次缺失
  • i=0 时总缺失次数 = 512 / 16 = 32 次

• 总缺失次数计算

  • 外层 i 循环从 0 到 512
  • 总缺失次数 = 512 × 32 = 16384

要构建 $2^{21}$ 位的存储器且每个字为 4 字节，因此存储器应包含的 4 字节数量为：

$$ \frac{2^{21}}{4 \times 8} = 2^{16} \text{ 个字} $$

已知使用的 RAM 芯片规格为 2K×8，目标存储器需满足 $2^{16}$ 个字的需求。
所需 RAM 芯片数量计算如下：
$$ \frac{2^{16} \times 32}{2K \times 8} = 32 \times 4 $$

因此，这些 RAM 芯片应排列为 32 行（每行 4 列）的结构。
需要译码器选择特定行，多路复用器选择特定列。由于有 32 行，需要 5-32 译码器选择目标行。
因此选项 (A) 正确。

所需芯片（128 x 8 RAM）数量计算如下：

• 总存储容量：2048 字节 × 8 位/字节 = $2048 \times 8$ 位
• 单个芯片容量：$128 \times 8$ 位
• 芯片数量：$\frac{2048 \times 8}{128 \times 8} = 16$

• 已知条件
  字长 = 64 位 = 8 字节
  块大小 = 256 字节
  每块字数 = 256 ÷ 8 = 32

• 未命中时的访问时间计算
  第一个字传输时间 = 20 ns
  后续 31 个字传输时间 = 31 × 5 ns = 155 ns
  总未命中时间 = 3 ns（缓存访问） + 20 ns + 155 ns = 178 ns

• 平均内存访问时间公式 $$ T_{avg} = (\text{命中率} \times \text{命中时间}) + ((1 - \text{命中率}) \times \text{未命中总时间}) $$ 代入数据： $$ T_{avg} = (0.94 \times 3) + (0.06 \times 178) = 2.82 + 10.68 = 13.5 \text{ns} $$ 四舍五入后结果为 13.5 ns

选项 (A) 正确。

解析：

• 参数计算

  • 块大小 = 256 字节 → 字偏移位 = log₂(256) = 8 位
  • 高速缓存总容量 = 64KB = 2¹⁶ B
  • 组数 = (64KB / 256B) / 4 路相联 = 256 / 4 = 64 组 → 组偏移位 = log₂(64) = 6 位

• 地址映射规则
  物理地址分为三部分：标记位 + 组索引 (6 位) + 字偏移 (8 位)
  取地址的第 8~13 位（从右往左编号）作为组索引

• 各地址组索引分析

  A1: 0x42C8A4 → C8 = 11001000 → 最低 6 位：001000 (8)
  A2: 0x546888 → 68 = 01101000 → 最低 6 位：101000 (40)
  A3: 0x6A289C → 28 = 00101000 → 最低 6 位：101000 (40)
  A4: 0x5E4880 → 48 = 01001000 → 最低 6 位：001000 (8)
  

• 结论
  A2 与 A3 的组索引均为 101000（十进制 40），因此映射到同一组。
  其他选项中组索引均不相同，故选 B

存储设备的访问速度从低到高的正确顺序为：

• 磁带
• 光盘
• 磁盘
• 电子盘
• 主存
• 高速缓存
• 寄存器

因此，选项 (D) 正确。

解析

硬盘中的数据按如下方式排列。最小的存储单位是扇区。多个扇区组合成一条磁道。柱面由位于相同半径位置的磁道组合而成。
读写头访问磁盘时，需要先移动到特定磁道，然后等待盘片旋转使目标扇区位于其下方。
此处，每个盘片有两个表面（即读写头可以从盘片的上下两面访问）。
因此，<400,16,29>表示已通过了 0-399 号柱面。每个柱面包含 20 个表面（10 个盘片 × 每个盘片 2 个表面），每个表面有 63 个扇区。
计算过程如下：

• 已通过 0-399 号柱面：400 × 20 × 63 = 504000 扇区
• 在第 400 号柱面中，已通过 0-15 号表面（共 16 个表面）：16 × 63 = 1008 扇区
• 当前在第 16 号表面上的第 29 号扇区：29 扇区

总扇区号 = 504000 + 1008 + 29 = 505037

可以通过上一题上传的图像辅助理解。

解析

(a) <0,15,31>

• 表示含义：第 0 柱面、第 15 磁头和第 31 扇区
• 计算过程：
  • 已经过 0 个柱面 → 0 × 20 × 63（每个柱面 20 个磁头，每个磁头 63 个扇区）
  • 已经过 15 个磁头（0-14）→ 15 × 63
  • 当前位于第 31 个扇区
• 总扇区编号：0 × 20 × 63 + 15 × 63 + 31 = 976
• 结论：不等于 1039，排除该选项

(b) <0,16,30>

• 表示含义：第 0 柱面、第 16 磁头和第 30 扇区
• 计算过程：
  • 0 × 20 × 63 + 16 × 63（0-15 磁头）+ 第 16 磁头上的 30 个扇区
• 总扇区编号：0 × 20 × 63 + 16 × 63 + 30 = 1038
• 结论：不等于 1039，排除该选项

(c) <0,16,31>

• 表示含义：第 0 柱面、第 16 磁头和第 31 扇区
• 计算过程：
  • 0 × 20 × 63 + 16 × 63（0-15 磁头）+ 第 16 磁头上的 31 个扇区
• 总扇区编号：0 × 20 × 63 + 16 × 63 + 31 = 1039
• 结论：与目标值相等，因此选项 C 正确

(d) <0,17,31>

• 表示含义：第 0 柱面、第 17 磁头和第 31 扇区
• 计算过程：
  • 0 × 20 × 63 + 17 × 63（0-16 磁头）+ 第 17 磁头上的 31 个扇区
• 总扇区编号：0 × 20 × 63 + 17 × 63 + 31 = 1102
• 结论：不等于 1039，排除该选项

解析

• 动态 RAM（DRAM）

  • 存储机制：通过电容存储数据
  • 刷新需求：需要周期性刷新以维持数据
  • 位密度：单位面积可集成的存储单元更多（位密度更高）
  • 功耗：频繁刷新操作会增加功耗

• 静态 RAM（SRAM）

  • 存储机制：使用触发器电路存储数据
  • 刷新需求：无需刷新
  • 位密度：相对较低
  • 功耗：整体功耗更低

解析：
ROM 存储容量公式为：2^m × n，其中：

• m 表示地址线条数（决定寻址空间）
• n 表示数据线条数（决定单次读取位宽）

题目中 16K × 16 可转换为 2^14 × 16，因此：

• 地址线数量 m = 14
• 数据线数量 n = 16

综上，选项 C 是正确答案

解析

• 选项 A：写回缓存需要脏位标记是否修改过数据，而写直达缓存不需要脏位（因为数据直接写入主存），因此该陈述错误。
• 选项 B：写命中时，写回缓存仅更新缓存内容，只有当块被驱逐时才可能触发主存更新，因此该陈述错误。
• 选项 C：写直达缓存每次写操作都同步到主存，驱逐块时无需额外传输数据，因此该陈述正确。
• 选项 D：读缺失可能导致 LRU 策略驱逐当前块，若该块为脏块则需写回主存，因此该陈述错误。

因此该题选 C。

解析

1. 基于中断服务程序的时钟周期数

这段中断服务例程的循环每次迭代要执行如下操作：

1. 从设备加载一个字节（load） → 2个周期
2. 存储到内存（store） → 2个周期
3. 增加地址寄存器（加法） → 1个周期
4. 减少计数器（减法） → 1个周期
5. 判断并跳转（条件跳转） → 1个周期

合计每次迭代：2 + 2 + 1 + 1 + 1 = 7 个时钟周期

循环共执行 500 次，所以中断服务总时钟周期 = 500 × 7 = 3500

2. 基于 DMA 控制器的执行周期数

初始化 DMA 控制器和开销：20个周期

每个字节传输 2 个周期，共 500 字节：500 × 2 = 1000 周期

总计：DMA 总周期 = 20 + 1000 = 1020

3. 加速比计算

加速比 = 中断服务程序所用时间 / DMA 方案所用时间 = 3500 / 1020 ≈ 3.43。

解析：

• 关键限制条件：

  • 总线占用时间为 100 ns（地址/数据/控制信号传输）
  • 内存模块内部操作周期为 600 ns（100 ns 同步 + 500 ns 异步）
  • 总线互斥性：同一时刻仅允许一个请求占用总线

• 性能瓶颈分析： 虽然单个内存模块需要 600 ns 完成完整操作，但 不同模块的操作可时间重叠。这意味着只要总线空闲即可发起新请求，无需等待前一模块完成全部操作。

• 最大吞吐量计算： $$ \text{1 毫秒} = 1{,}000{,}000 \text{ ns} \ \frac{1{,}000{,}000 \text{ ns}}{100 \text{ ns/请求}} = 10{,}000 \text{ 次} $$ 因此，总线利用率决定最大请求数，与内存模块数量无关。

已知总行数为 2¹⁴，执行一次刷新操作所需时间为 50 纳秒。

• 总刷新时间计算 $ 2^{14} \times 50 , \text{ns} = 819200 , \text{ns} = 0.8192 , \text{ms} $

• 刷新周期内时间占比 $ \frac{0.8192 , \text{ms}}{2 , \text{ms}} = 0.4096 = 40.96% $

• 可用时间计算 $ 100% - 40.96% = 59.04% \approx 59% $（四舍五入）

最终答案为 59。

解析：

1. 单个芯片容量计算

   • 每个芯片大小 = 8K × 4 位 = $2^3 \times 2^{10} \times 2^2$ 位 = $2^{15}$ 位
   • 转换为字节：$2^{15} \div 8 = 2^{12}$ 字节

2. 芯片数量与地址需求

   • 阵列为 4×6，共需 24 片芯片
   • 寻址 24 个芯片需要 $\log_2{24} \approx 5$ 条地址线

3. 总地址线数

   • 单芯片地址线：12 条（对应 $2^{12}$ 字节）
   • 芯片选择线：5 条
   • 总计：12 + 5 = 17 条地址线

要构建的存储器容量为 2²¹位，采用 4 字节字结构。因此存储器应包含的 4 字节数量为：

2²¹ / (4×8) = 2¹⁶ 个字

给定的 RAM 芯片规格为 2K x 8 使用这些 RAM 芯片构建的目标存储器为 2¹⁶ 字 所需 RAM 芯片数量计算如下： (2¹⁶ × 32)/(2K × 8) = 32 × 4

因此 RAM 芯片的排列应包含 32 行（每行 4 列）。

需要译码器选择特定行，多路复用器选择特定列。由于有 32 行，因此需要 5 到 32 的译码器选择目标行。

所以选项 (A) 正确。

解析

• 数据转换

  • 9600 bps = 9600/8 Bps = 1200 字节/秒
  • 处理器速度 = 1 MIPS = 10⁶ 条指令/秒

• 时间计算

  • 减速时间 = $\frac{1200}{10^6}$ 秒 = $\frac{12 \times 1000}{10^4}$ ms
  • 最终结果 = 1.2 ms

• 结论 DMA 操作导致处理器每秒需额外处理 1200 字节的数据，相当于每秒减少 1.2 ms的指令执行时间。

• 写直达：字被同时写入高速缓存和主存储器
• 回写：字仅写入高速缓存，实际更新到主存储器的对应位置只在指定时间间隔或特定条件下进行
• 写保护：数据无法被修改或删除
• 直接映射：主存储器的第 M 块映射到高速缓存的第 M mod n 块（n 为高速缓存总块数）

因此，选项 (A) 正确。

解析：

1. 计算内存块号

   $$ \text{内存块号} = \left\lfloor \frac{\text{字节地址}}{\text{块大小}} \right\rfloor = \left\lfloor \frac{1206}{16} \right\rfloor = 75 $$

2. 计算缓存块号 $$ \text{缓存块号} = \text{内存块号} \bmod \text{缓存块数} = 75 \bmod 64 = 11 $$

因此，字节地址 1206 会映射到缓存块号 11，对应选项 (C)。

解析

1. 首先分析以下基本设定
   • 高速缓存访问时间：50 ns
   • 主存访问时间：300 ns
   • 读操作命中率：80%
   • 读写频率比：读75%/写25%
2. 读写时间计算
   • 读操作时间 (t_read)：
     • = 命中率×缓存时间 + (1-命中率)×(缓存时间+主存时间)
     • = 0.8×50 + 0.2×(50+300) = 110 ns
   • 写操作时间 (t_write)：
     • = max(主存时间, 缓存时间) = max(300,50) = 300 ns
3. 平均加权时间
   • = 读频率 × t_read + 写频率 × t_write
   • = 0.75×110 + 0.25×300 = 157.5 ns

所以答案选择 A。

解释：

• CMOS 是一种 易失性存储器（RAM），依赖持续供电来保存数据。
• 计算机关机后，主板电池为其供电，因此归类为 RAM。
• 其他选项：
  • ROM/EPROM 属于 非易失性存储器。
  • 辅助存储器 通常指硬盘等外部存储设备。

• 页面大小 = 4KB = $2^{12}$
• 寻址页框所需的总位数 = 32 – 12 = 20

组相联映射分析

• 若一组中有 n 个缓存行，则称为 n 路 组相联
• TLB 是 4 路组相联，共 128（$2^{7}$）个页表项
• 组数 = $2^7 / 4 = 2^5$ → 需要 5 位寻址组
• 剩余标记位数 = 总页框位数 - 组索引位数 = 20 - 5 = 15 位

解析

• 虚拟地址总大小：40 位
• 组偏移：由于 TLB 有 32 组（2⁵），因此组偏移为 5 位
• 字偏移：页面大小为 8KB（2¹³ 字节），因此字偏移为 13 位
• 最小标记长度：40 - 5 - 13 = 22 位

解析：

• 运行时程序重定位需要将整个代码块移动到某些内存位置。

• 此过程需要 基地址 并通过该基地址进行 相对寻址。

• 因此需要同时使用基地址和相对地址，故选项 (C) 是正确的。

• 绝对寻址模式 和 间接寻址模式 仅适用于单条指令，而非整个代码块，因此不适合运行时的程序重定位。

解析

1. 指令地址分配规则

   • 内存按字节寻址，32 位宽度 ⇒ 每个字 = 4 字节
   • 指令地址按字对齐（即地址值为 4 的倍数）

2. 逐条指令地址计算

   地址范围       指令名称        大小 (字)  大小 (字节)
   1000-1007     MOV R1,5000     2       8
   1008-1011     MOV R2,(R1)     1       4
   1012-1015     ADD R2,R3       1       4
   1016-1023     MOV 6000,R2     2       8
   1024-1027     HALT            1       4
   

3. 中断处理机制

   • 中断发生时，CPU 会将 下一条指令的地址 压入堆栈作为返回地址
   • HALT 指令地址为 1024-1027，其下一条指令地址为 1028
   • 因此堆栈中保存的返回地址为 1028

4. 关键验证点

   • 所有指令均严格按 4 字节对齐
   • 最终 HALT 指令地址为 1024，执行完成后 PC 指向 1028
   • 中断触发时机为 HALT 指令执行后，故返回地址为 1028

解释：每个指令块的时钟周期计算方式为：若指令大小为 2，则需乘以 2 倍的时钟周期数。

• MUX 有 8 条状态位作为输入线，因此需要 3 个选择输入来选择输入线
• 控制存储器下一个地址字段的位数 = 26 - 13 - 3 = 10
• 10 位寻址对应 2¹⁰ 内存大小

结论
X 字段为 10 位，Y 字段为 3 位，控制存储器容量为 1024 字
因此 (A) 是正确选项

• 核心逻辑：只有当进位标志为 1 时，B 会递增 1。
• RRC 指令行为：
  • RRC A, #1 将累加器 A 的每一位向右旋转一位。
  • 最低位（D0）会被复制到进位标志（CY），同时作为高位插入 D7 位置。
• 执行过程：
  1. 初始 C = 8，循环 8 次（对应 A 的 8 位）。
  2. 每次 RRC 后，若进位标志为 1（即当前位为 1），则跳转至 Y 执行 B = B + 1。
  3. 最终 B 的值等于 A0 中 1 的数量。
• 结论：程序统计了 A0 中二进制 1 的个数，因此选项 (B) 正确。

解析：

• 在程序执行结束时，为了使寄存器 A 的值与初始值相同，需通过进位标志进行右循环移位。
• RRC 指令的作用：
  • 累加器的每一位向右循环移动一位。
  • D0 位被放置在 D7 位和进位标志中。
  • CY 根据 D0 位进行修改。
  • 其他位不受影响。

因此，选项 (A) 是正确的。

解析：

1. INTR 是中断请求信号，用于通知 CPU 有外部设备需要中断服务
2. 当 CPU 接收到高电平 INTR 信号后，会通过 INTA（Interrupt Acknowledge）信号与外设通信
3. 在 CPU 处理当前中断的整个过程中（即活动期间），会持续屏蔽其他中断请求

结论：
由于 CALL 指令是在 CPU 响应中断并进入中断处理程序时由 CPU 自动执行的，因此正确时机是 活动期间，对应选项 A。

程序计数器是存储程序下一步执行地址的寄存器。其工作原理如下：

• JMP 与 CALL 指令：直接修改 PC 值，实现跳转和子程序调用
• JMP 指令：跳转到目标地址
• ADD 指令：执行后 PC 自动递增以指向下一个指令地址

由于每条指令执行后 PC 都会发生变化（无论是显式修改还是隐式递增），因此所有指令都会以某种方式修改程序计数器。

正确答案：(D)

解析

• B 是正确答案。绝对寻址方式表示操作数的地址直接包含在指令中。
  ❌ 错误选项解析：
• A 操作数在指令中 → 立即寻址
• C → 寄存器寻址
• D → 隐式寻址

堆栈指针寄存器保存堆栈顶部的地址，这是 CPU 在处理完中断或子程序调用后应恢复执行的内存位置。

因此，如果没有 SP 寄存器，则不可能有任何子程序调用指令。因此选项（A）正确。

软件中断是 CPU 获取系统服务所必需的，这些服务需要执行特权指令。其核心机制包括：

• 触发方式：通过特殊指令（如 INT 指令）或异常条件（如除零错误）激活
• 处理流程：
  1. 处理器暂停当前代码执行
  2. 保存程序状态（寄存器、程序计数器等）
  3. 跳转至预设的中断处理程序（ISR）
  4. 完成处理后恢复现场并继续执行

与硬件中断不同，软件中断由程序主动发起，常用于系统调用（如文件操作、进程控制）。选项 C 准确描述了其核心用途，而其他选项分别对应测试手段（A）、并发编程技术（B）和常规跳转指令（D）。

因此，(C) 是正确选项

解析

• 特权模式（privileged mode）：也称内核模式，允许执行所有指令，包括控制硬件、修改系统状态等特权操作。
• 非特权模式（unprivileged mode）：也称用户模式，仅能执行一部分指令，不能访问某些关键资源。

模式切换说明：

• 从 特权模式切换到非特权模式 是为了从操作系统内核切回用户程序。
• 这个切换 不会触发中断，也不需要中断，因为这是内核主动让出 CPU。
• 这个过程 必须通过一条特权指令完成。

解析：

• 索引寻址 用于数组实现，其中每个元素都有索引。
• 基址寄存器寻址 用于可重定位代码，其从基地址开始，所有局部地址都加到基地址上。
• 间接寻址 在将数组作为参数传递时使用，此时仅传递名称。
  因此选项 (A) 是正确答案。

解析：

1. 在微程序控制单元中，块 B 负责存储当前执行的微指令地址，对应 控制地址寄存器（Control Address Register）
2. 块 C 存储所有微指令的集合，对应 控制存储器（Control Memory）
3. 高速缓存存储器和随机访问存储器属于主存扩展范畴，与微程序控制器核心组件无关
4. 因此选项 (B) 完全符合微程序控制器的标准架构定义

• 解析：
  • JNBE 指令全称为 “Jump if Not Below or Equal”（不小于也不等于则跳转）
  • 跳转条件需同时满足两个标志位状态：
    • CF = 0：表示无借位（未发生无符号数比较中的下溢）
    • ZF = 0：表示结果非零（排除了相等的情况）
  • 对应逻辑表达式：CF == 0 && ZF == 0
  • 其他选项分析：- A 选项仅需一个条件成立，不符合 JNBE 的语义 - B 选项涉及 SF 标志，与无符号数比较无关 - D 选项缺少对 ZF 的判断，无法区分大于/等于情况

A1: MOV AL, 00H // AL 的值为 0000 0000
INC AL // 增量 AL
JNZ A1 // 当 AL=0 时跳转到 A1，此时 AL = 0000 0000

执行流程分析：

1. 初始状态：AL 被设置为 0000 0000 (0)
2. 每次执行 INC AL 后：
   • 第 1 次 → 0000 0001 (1)
   • 第 2 次 → 0000 0010 (2)
   • …
   • 第 255 次 → 1111 1111 (255)
3. 第 256 次执行：
   • INC AL 将 1111 1111 (255) 变为 1 0000 0000 (256)
   • 因 AL 是 8 位寄存器，最高位进位丢失，实际存储为 0000 0000 (0)
4. 此时 JNZ A1 检测到 ZF=1（零标志置位），不再跳转，循环终止

结论：

• 完成 256 次完整的循环迭代（包含初始值 0）
• 最终因寄存器溢出触发零标志而退出循环

选项 (C) 正确。

1. 初始状态：

   • al = 15（即 0Fh）
   • ah = 15（即 0Fh）
   • 因此 ax = 000F 000F（即 0F0Fh）

2. 执行 xor al, al 后：

   • al 被清零，变为 0
   • 此时 ax = 000F 0000（即 0F00h）

3. 设置 cl = 3 并右移：

   • 使用 shr ax, cl 对 ax 逻辑右移 3 位
   • 结果：000F 0000 → 0001 E000（即 01E0h）

最终结果为选项 C。

解析

• MVI B, 82H：将寄存器 B 赋值为 82H
• MOV A, B：将 B 的内容（82H）复制到累加器 A 中
• MOV C, A：将 A 的内容（82H）复制到寄存器 C 中
• MVI D, 37H：将寄存器 D 赋值为 37H，但此操作不影响累加器 A
• OUT PORT1：将累加器 A 的当前值（82H）输出到 PORT1
• HLT：程序终止

结论：最终输出为 82H，对应选项 B

在实模式下，物理地址通过公式 (CS << 4) + IP 计算。具体步骤如下：

1. 段地址计算：将 CS 值 1000 左移 4 位（等效于乘以 16），结果为 10000。
2. 物理地址合成：将段地址 10000 与偏移量 E000 相加，最终得到 1E000。 因此，正确答案为 A。

• 若 I3 单独执行（无其他中断）
  时间间隔 = 中断响应时间 + 执行时间 = 4.5 + 20 微秒 = 24.5 微秒

• 若 I3 与其他中断同时发生
  时间间隔 = 中断响应时间 + I1、I2、I3 的执行时间总和
  = 4.5 + 25 + 4.5 + 35 + 4.5 + 20 = 93.5 微秒

因此，选项 (B) 正确。

解析

8086 的特点：

• 16 位数据线
  意味着字长为 2 字节，可在单个内存周期内读取两个字节
• 20 位地址线
  表示内存大小为 $2^{20}$ 字节 = 1 兆字节

因此，选项 (A) 正确。

解析：
TRAP 中断具有以下特性：

1. 不可屏蔽性：TRAP 属于非屏蔽中断（NMI），其优先级高于所有可屏蔽中断（如 RST 7.5/6.5/5.5）。
2. 复合触发机制：
   • 需同时检测到 正边沿（上升沿） 和 高电平 才能触发中断请求。
   • 这种设计避免了因短暂噪声导致的误触发。
3. 硬件实现逻辑：
   • 内部电路通过与门实现「正边沿 + 高电平」的双重验证。
   • 确保只有稳定有效的信号才能激活中断。

因此，选项 D（同时由正边沿和负边沿触发）是唯一正确的描述。

解析：

• 外部数据总线宽度为 16 位（即每次传输 2 字节）
• 总线时钟频率为 8 MHz
• 最短总线周期包含 4 个时钟周期 → 周期速率为 $ \frac{8\ \text{MHz}}{4} = 2\ \text{M/秒} $
• 数据传输速率 = 周期速率 × 每周期数据量 = $ 2\ \text{M} \times 2 = 4 \times 10^6\ \text{字节/秒} $
  因此，选项 (B) 正确。

初始时，寄存器对 BC 被加载为 0007H（即 B=00H，C=07H）。每次循环中：

1. DCX B 将 BC 减 1。
2. MOV A, B 将 B 的值（高位字节）移动到累加器 A。
3. ORA C 将 A 与 C（低位字节）进行逻辑或运算。若结果非零，则设置零标志位为 0。
4. JNZ LOP 根据零标志位决定是否跳转回循环起点。

由于 BC 初始值为 0007H，每次循环后递减 1，直到 BC 变为 0000H 时停止。具体过程如下：

• 第 1 次：BC=0006H → ORA 结果为 06H（非零）→ 继续循环
• 第 2 次：BC=0005H → ORA 结果为 05H → 继续循环
• …
• 第 7 次：BC=0000H → ORA 结果为 00H（零）→ 停止循环

因此循环共执行 7 次，正确答案为选项 B。

I. 正确
链式连接方法通过将所有可能请求中断的设备串联起来，并根据设备优先级进行排序。优先级最高的设备排在最前面，其次是次高优先级设备，依此类推。

II. 错误
向量中断不涉及轮询，而非向量中断才需要轮询。
向量中断通过为每个中断设备分配唯一的代码（通常为 4-8 位）实现。当设备触发中断时，它会通过数据总线将唯一代码发送给处理器，指示处理器执行对应的中断服务程序。

III. 正确
轮询是一种协议，而非硬件机制。CPU 会持续检查设备是否需要关注。

IV. 错误
在 DMA 期间，CPU 和 DMA 控制器不能同时作为总线主控设备。
CPU 只有在收到 DMA 请求后才会释放总线，并在 DMA 释放总线后重新获得控制权。

选项 (C) 是正确答案。

解析

1. 通过 MAR 将地址发送到内存：PCr , MARw , MEMr
2. 从内存通过 MDR 将操作码读入 IR：MDRr , IRw
3. 将第一个操作数发送到 Temp1（ALU）：R1r , TEMP1w
4. 直接从 R2 读取第二个操作数并在 ALU 中处理数据并存储结果到 TEMP2：R2r , TEMP1r , ALUadd , TEMP2w
5. 将结果存储到 R0：TEMP2r , R0w

选项 (C) 正确。了解更多关于指令周期的内容

• 关键分析
  • 单次请求的发起耗时 100 ns（总线占用时间）
  • 内存模块内部操作（500 ns）可与其他模块操作重叠
  • 总线独占特性导致请求需串行发起
• 计算逻辑
  • 1 毫秒 = 1,000,000 ns
  • 最大请求数 = 总时间 ÷ 单次请求间隔 = 1,000,000 ns ÷ 100 ns = 10,000
• 结论
  在保证总线独占的前提下，通过利用内存模块内部操作的重叠性，每 100 ns 可发起一次新请求，最终得出最大存储次数为 10,000 次。

解析：

• 单个中断请求线（INTR）和授权线（INTA）的 CPU 仍可通过 中断控制器 或 优先级编码器 实现多个中断设备的接入。
• 向量中断的关键在于设备能直接提供中断服务程序入口地址，而非依赖物理线路数量。
• 因此，即使只有一对中断线，也能通过硬件逻辑支持 多个中断源 和 向量中断机制。

• SP 输出，MAR 输入：2 周期（因 SP 为 16 位而系统总线为 8 位）
• A 输出，MDR 输入：1 周期
• M[MAR] ← MDR：2 周期
  总计：5 周期，选项 D 为正确答案

解析
根据各指令对 Ain 信号的使用情况分析：

• I1 在 T1 和 T3 触发 Ain
• I2 仅在 T3 触发 Ain
• I3 在 T2 和 T4 触发 Ain

选项 A（T1·I1 + T2·I3 + T4·I3 + T3）完整覆盖了所有触发 Ain 的情况：

• T1·I1 对应 I1 的 T1 阶段
• T2·I3 对应 I3 的 T2 阶段
• T4·I3 对应 I3 的 T4 阶段
• T3 则统一处理 I1/I2/I3 的 T3 阶段（三者均在 T3 触发 Ain）

其他选项均存在遗漏或冗余条件。

选项 D 正确。根据题目描述：

• S5 的生成条件：

  • 始终在 T1 时钟周期有效（对应所有指令）
  • 在 I2 和 I4 指令的 T3 阶段有效

• S10 的生成条件：

  • 在 I2 和 I3 指令的 T2 阶段有效
  • 在 I4 指令的 T3 阶段有效
  • 在 I1 和 I3 指令的 T4 阶段有效
  • 在 I2 和 I4 指令的 T5 阶段有效

选项 D 完整覆盖了上述所有条件，其他选项均存在部分时间步长或指令组合缺失的情况。

在水平微编程中，每个控制信号由微指令中的 1 位表示。因此，水平微编程所需的控制字总位数为：
20 + 70 + 2 + 10 + 23 = 125 位

在垂直微编程中，n 个控制信号通过 log₂n 位进行编码。具体计算如下：

• 第 1 组：log₂20 ≈ 5 位
• 第 2 组：log₂70 ≈ 7 位
• 第 3 组：log₂2 = 1 位
• 第 4 组：log₂10 ≈ 4 位
• 第 5 组：log₂23 ≈ 5 位

垂直微编程所需总位数为：5 + 7 + 1 + 4 + 5 = 22 位
因此，节省的位数为 125 - 22 = 103 位。选项 (B) 正确。

• 每条指令需要 7 个周期 → 140 条指令总共需要 $140 \times 7 = 980$ 个周期
• 控制地址寄存器需满足 $2^m \geq 980$ → 最小 $m = 10$ 位
• 控制字由两部分组成：
  • 125 位用于表示控制信号
  • 10 位用于地址字段
• 因此控制字总长度为 $125 + 10 = 135$ 位
• 最终结果为 135 位控制字 和 10 位控制地址寄存器

解析：

• 硬布线控制：基于纯硬件实现，无需软件干预，执行效率最高。
• 水平微编程：控制信号直接以并行方式表示，无需解码操作，速度优于垂直微编程。
• 垂直微编程：通过编码压缩控制信号（节省存储），但需额外解码步骤，速度最慢。

结论：
操作速度排序为：
硬布线控制 > 水平微编程 > 垂直微编程

• 现代 CPU 通常具有一个中断使能标志（Interrupt Enable Flag）
  该标志未设置时，CPU 将忽略所有中断请求。只有当该标志被设置为允许状态时，CPU 才会响应和处理中断。

• 选项 B 错误
  某些架构支持中断抢占循环（如 x86 架构中的中断优先级机制），并非所有循环指令都无法被中断。

• 选项 C 描述的是中断检查时机
  但并非所有处理器都采用“执行新指令前检查中断”的设计（如某些 RISC 架构在流水线阶段检查中断）。

• 选项 D 错误
  微处理器同时支持边沿触发和电平触发两种中断方式（如 ARM 架构的中断控制器支持混合模式）。

• “神威·太湖之光”被命名为世界上最快的超级计算机，其运行速度可达 93 PFLOPS。
• 泰坦超级计算机的速度为 27 PFLOPS 理论峰值。
• 皮兹·戴恩特超级计算机的速度为 25.326 PFLOPS。
• 序列亚超级计算机的速度为 20.13 PFLOPS。

因此，选项（A）正确。

解析：
根据 Amdahl 定律，无限进程数的加速比公式为：
$$ S = \frac{1}{1 - P} $$
其中 $ P $ 表示程序的并行部分比例。

1. 确定参数
   程序的顺序部分占比为 5%，即 $ 1 - P = 0.05 $，因此并行部分 $ P = 1 - 0.05 = 0.95 $。

2. 代入公式计算

   $$S = \frac{1}{1 - 0.95} = \frac{1}{0.05} = 20$$

3. 结论
   最大理论加速比为 20，因此选项 (C) 正确。

• 独立 I/O 方法：通过隔离内存和 I/O 地址空间，确保内存地址范围不会受到接口地址分配影响
• 内存映射 I/O (Memory-mapped I/O)：使用相同的地址空间来访问内存和 I/O 设备
• 异步串行传输：两个设备不共享公共时钟
• 同步串行传输：两个设备共享公共时钟

参考：I/O 接口。选项 B 正确。

解析：

• 高速缓存命中率 $ H_{\text{cache}} = 0.8 $
• 高速缓存访问时间 $ T_{\text{cache}} = 30 , \text{ns} $
• 主存储器访问时间 $ T_{\text{memory}} = 150 , \text{ns} $

计算公式：

$$ \text{CPU 访问时间} = H_{\text{cache}} \times T_{\text{cache}} + (1 - H_{\text{cache}}) \times (T_{\text{cache}} + T_{\text{memory}}) $$

代入数值：

$$ = 0.8 \times 30 + 0.2 \times (30 + 150) = 24 + 36 = 60 , \text{ns} $$

因此，选项 (A) 正确。

C
解析：

1. 单位换算与需求分析

   • 目标容量：256 KB = 256 × 1024 字节 = 256 × 1024 × 8 位
   • 单个芯片容量：32 KB × 1 位 = 32 × 1024 位

2. 计算芯片数量

   $$ \text{所需芯片数} = \frac{\text{总需求位数}}{\text{单个芯片位数}} = \frac{256 \times 1024 \times 8}{32 \times 1024} = 64 $$

3. 结论
   需要 64 个 32K×1 的 RAM 芯片，选项 (C) 正确。

用于存储屏蔽中断所需位的寄存器是中断屏蔽寄存器。

• 用于存储状态所需位的寄存器是状态寄存器
• 用于存储中断服务所需位的寄存器是中断服务寄存器
• 用于存储中断请求所需位的寄存器是中断请求寄存器
  因此，选项 (C) 正确。

解析：

• 在寄存器间接寻址方式中，操作数存储在内存中，其内存地址由指令中指定的寄存器提供。
• 更多相关信息可参考：Addressing Modes。
• 正确答案为 (B)。

在变址寻址方式（Index mode）中，有效地址由寄存器内容（基地址）和指令中的位移量（常量）相加得到。其他选项特性如下：

• 绝对寻址方式：直接使用指令中的地址值作为有效地址
• 间接寻址方式：寄存器或内存单元存储的是操作数地址的指针
• 立即寻址方式：操作数直接包含在指令中，无需地址计算

功能解析

• 内存地址寄存器（MAR）是 CPU 中的寄存器
• 主要作用：存储将从内存中提取数据的地址
• 或存储将数据发送并保存到的目标地址

选项分析

• 选项（C）准确描述了 MAR 的核心功能
• 其他选项均未正确反映 MAR 的实际用途

解析：
大端序（Big-endian）是一种存储顺序，其中序列中的“大端”即最重要的值会首先存储在最低的存储地址中。

以 32 位整数 0x12345678 为例：

这种存储方式与人类书写数字的习惯一致（如十进制数从左到右按高位到低位排列），因此选项 (A) 是正确的。