D. 8
解析:计算每个关键字的位置: 10->10, 22->0, 31->9, 4->4, 15->4冲突线性探测到5, 28->6, 17->6冲突线性探测到7, 88->0冲突线性探测到1, 59->4冲突，然后线性探测5冲突(有15),6冲突(有28),7冲突(有17),8空，所以存储在第8位。

A. D E B F C A
解析:从前序和中序构建树:前序第一个A是根，中序中A左边是左子树D B E，右边是右子树F C。左子树前序B D E，中序D B E，所以B是根，左孩子D，右孩子E。右子树前序C F，中序F C，所以C是根，左孩子F。树结构为A左孩子B右孩子C，B左孩子D右孩子E，C左孩子F。后序遍历顺序为左子树、右子树、根，所以左子树后序D E B，右子树后序F C，根A，因此后序序列为D E B F C A。

C. 30
解析:插入20,10,30后树平衡，根为20。插入5和15后仍平衡。插入25和35后仍平衡。插入40后，在节点20处平衡因子为-2(右子树高度3，左子树高度2)，且右孩子30的平衡因子为-1，因此需要左旋操作。左旋后，根节点变为30。

A. B,D,C,E
解析:执行操作: push(A)栈[A], push(B)栈[A,B], pop()出B栈[A], push(C)栈[A,C], push(D)栈[A,C,D], pop()出D栈[A,C], pop()出C栈[A], push(E)栈[A,E], pop()出E栈[A]。所以出栈序列为B,D,C,E。

A. 1,2,3,4
解析:执行操作: enqueue(1)队列[1], enqueue(2)队列[1,2], dequeue()出1队列[2], enqueue(3)队列[2,3], enqueue(4)队列[2,3,4], dequeue()出2队列[3,4], dequeue()出3队列[4], enqueue(5)队列[4,5], dequeue()出4队列[5]。所以出队序列为1,2,3,4。

A. [0,0,1,2,0]
解析:计算next数组: next[0]=0; next[1]模式"AB"，最长相同前后缀长度为0，所以0; next[2]模式"ABA"，前缀"A"和后缀"A"相同，长度1，所以1; next[3]模式"ABAB"，前缀"AB"和后缀"AB"相同，长度2，所以2; next[4]模式"ABABC"，无相同前后缀，长度0，所以0。因此next数组为[0,0,1,2,0]。

C. 2.5
解析:对于线性探测，查找成功的平均探查次数公式为(1/2)(1 + 1/(1-α))。当α=0.75时，计算为(1/2)(1 + 1/0.25) = (1/2)(1+4) = 2.5。

B. 4
解析:高度为3的二叉树最多有7个节点（满二叉树），但本题有10个节点，因此高度至少为4。同时，存在高度为4且只有3个叶子节点的二叉树（例如，一条链上有部分分支），因此最小高度为4。

C. O(n^2)
解析:当数组逆序时，每次划分将数组分为一个元素（枢轴）和剩余部分，导致划分极度不平衡，最坏情况时间复杂度为O(n^2)。

A. 25
解析:图的边数e与度之和的关系为2e = ∑度。每个顶点的度至少为5，因此度之和至少为10×5=50，所以2e ≥ 50，e ≥ 25。

A. 20
解析:通过红黑树插入规则：插入10为根（黑）；插入20为10的右孩子（红），平衡；插入30时需左旋和变色，根变为20（黑）；插入40时需变色，根仍为20；插入50时需左旋和变色，根仍为20；插入60和70时需调整，但根始终保持为20。

B. $17$位。

解析：缓存大小$128\mathrm{KB}=131072\mathrm{B}$，块大小$32\mathrm{B}$，所以总块数$=131072/32=4096$块。$4$路组相联，组数$=4096/4=1024$组。偏移位$=\log_2(32)=5$位，索引位$=\log_2(1024)=10$位，标签位$=32-10-5=17$位。

C. $3$。

解析：对于$\mathrm{LW}$指令和$\mathrm{ADD}$指令之间的数据相关（Load-Use hazard），在没有数据转发时，需要插入$2$个气泡；对于$\mathrm{ADD}$指令和$\mathrm{SUB}$指令之间的数据相关（ALU-ALU hazard），需要插入$1$个气泡。因此总共需要插入$3$个气泡。

C. $2^{-24}$。

解析：精确值为$1.0 + 2^{-24}$，在单精度中，由于$2^{-24}$等于尾数最低有效位值（$2^{-23}$）的一半，根据舍入到偶数的规则，舍入到$1.0$，因此误差为$2^{-24}$。

B. $20\mathrm{ns}$。

解析：在链式查询中，当离仲裁器最近的设备请求时，仲裁可以在$1$个时钟周期内完成，然后数据传输需要$1$个时钟周期，所以最短时间为$2$个时钟周期，即$20\mathrm{ns}$。

B. $10\%$。

解析：设备数据率为$10\mathrm{KB/s}$，所以每秒产生$10000$次中断。每次中断处理需要$100$条指令，执行时间为$100\times0.1\mathrm{\mu s}=10\mathrm{\mu s}$。每秒总中断处理时间为$10000\times10\mathrm{\mu s}=100000\mathrm{\mu s}=0.1\mathrm{s}$，因此CPU用于I/O的时间占比为$10\%$。

A. $\mathrm{0x70000000} + \mathrm{0x70000000}$。

解析：$\mathrm{0x70000000}$是正数（最高位为$0$），两个正数相加得到$\mathrm{0xE0000000}$，符号位为$1$，结果为负数，因此溢出。其他选项：B是负数加正数，结果在范围内，无溢出；C是正数加负数，结果在范围内，无溢出；D是两个正数相加结果为正数，无溢出。

C. $6.5\mathrm{ns}$。

解析：读操作平均时间 $= 0.95 \times 2\mathrm{ns} + 0.05 \times (2\mathrm{ns} + 100\mathrm{ns}) = 1.9\mathrm{ns} + 5.1\mathrm{ns} = 7\mathrm{ns}$；写操作平均时间 $= 0.95 \times 1\mathrm{ns} + 0.05 \times 100\mathrm{ns} = 0.95\mathrm{ns} + 5\mathrm{ns} = 5.95\mathrm{ns}$；整体平均时间 $= 0.7 \times 7\mathrm{ns} + 0.3 \times 5.95\mathrm{ns} = 4.9\mathrm{ns} + 1.785\mathrm{ns} = 6.685\mathrm{ns} \approx 6.5\mathrm{ns}$（四舍五入）。

A. 0。

解析：在数据转发机制下，\mathrm{ADD}指令在\mathrm{EX}阶段产生\mathrm{R1}的值，\mathrm{LW}指令在\mathrm{EX}阶段需要\mathrm{R1}用于地址计算（而非\mathrm{ID}阶段），数据转发可以从\mathrm{ADD}的\mathrm{EX/MEM}寄存器转发到\mathrm{LW}的\mathrm{EX}阶段ALU输入，因此不需要插入气泡。\mathrm{LW}指令在\mathrm{MEM}阶段结束时产生\mathrm{R4}的值（从内存加载），\mathrm{SW}指令在\mathrm{MEM}阶段需要\mathrm{R4}作为存储数据（而非\mathrm{ID}阶段），数据转发可以从\mathrm{LW}的\mathrm{MEM/WB}寄存器转发到\mathrm{SW}的\mathrm{MEM}阶段，因此也不需要插入气泡。总共需要插入0个气泡。

D. $4\mathrm{GB}$。

解析：页面大小$4\mathrm{KB}$，页内偏移$12$位，虚拟页面号$20$位。一级页表大小$4\mathrm{KB}$，页表项$4$字节，所以一级页表有$1024$个项。每个项指向一个二级页表，每个二级页表大小$4\mathrm{KB}$，有$1024$个项，所以总虚拟页面数为$1024\times1024=2^{20}$页，虚拟地址空间大小为$2^{20}\times4\mathrm{KB}=4\mathrm{GB}$。

B. 结果$\mathrm{0x00}$，溢出$1$。

解析：$\mathrm{0x80}$在$8$位补码中表示$-128$，$-128 + (-128) = -256$，在$8$位下结果为$\mathrm{0x00}$，但两个负数相加得到正数，溢出，因此溢出标志为$1$。

C. $75\%$。

解析：控制存储器容量为$512\times64$位，表示有$512$个微指令单元（存储器单元数通常为2的幂次，此处$512=2^9$，符合硬件设计规范）。指令系统有$96$种指令，平均每条指令需要$4$条微指令（微指令是微程序的基本单位，每条微指令可实现一组并行微操作，题目明确“每条指令需4条微指令”，符合微程序设计逻辑），因此总微指令数为$96 \times 4 = 384$条。控制存储器利用率为$\frac{384}{512} \times 100\% = 75\%$。

正确答案是B。

速率单调调度的可调度条件为总利用率$U \leq n(2^{1/n} - 1)$，其中$n$为任务数。这里$n=3$，$U = \frac{20}{50} + \frac{30}{100} + \frac{50}{200} = 0.4 + 0.3 + 0.25 = 0.95$。$n(2^{1/3} - 1) \approx 3 \times (1.2599 - 1) = 3 \times 0.2599 = 0.7797$。由于$0.95 > 0.7797$，因此系统不可调度。

正确答案是A。

页面大小$4\text{KB}=2^{12}$字节，因此页内偏移占12位。虚拟地址32位，所以虚页号占20位。第一级页表索引占10位，因此第一级页表有$2^{10}=1024$个页表项。每个页表项4字节，所以第一级页表大小为$1024 \times 4 = 4096$字节 = $4\text{KB}$。

正确答案是A。

计算每个进程的需求数（$\text{Need} = \text{Max} - \text{Allocation}$）：P1 $\text{Need}=2$, P2 $\text{Need}=3$, P3 $\text{Need}=3$。当前可用资源为2。可以找到安全序列：首先满足P1（$\text{Need}=2 \leq$ 可用2），P1完成后释放资源，可用变为$2+1=3$；然后满足P2（$\text{Need}=3 \leq$ 可用3），P2完成后可用变为$3+1=4$；最后满足P3（$\text{Need}=3 \leq$ 可用4）。因此系统处于安全状态。

正确答案是B。

每个索引块可以存储的索引项数为：$1\text{KB} / 4\text{字节} = 1024 / 4 = 256$个。由于文件有100个数据块（小于256），因此只需要一个索引块。访问第100个数据块时，需要先将索引块读入内存（1次磁盘I/O），然后根据索引项读取数据块（1次磁盘I/O），共2次磁盘I/O。

正确答案是A。

信号量的值变化取决于$P$和$V$操作的数量。初始$S=1$。$P$操作减少$S$，$V$操作增加$S$。总$P$操作次数为3，总$V$操作次数为2。因此，净变化为 $-1$，最终$S=1-1=0$。尽管在执行过程中$S$可能为负（表示有进程阻塞），但所有操作完成后，$S$的值为0。

正确答案是B。

SCAN算法磁头从53向0移动，服务所有小于53的请求：37、14（服务顺序为$53\rightarrow37\rightarrow14$），然后反向移动服务大于14的请求：65、67、98、122、124、183。寻道距离计算：$53\rightarrow37$（16），$37\rightarrow14$（23），$14\rightarrow65$（51），$65\rightarrow67$（2），$67\rightarrow98$（31），$98\rightarrow122$（24），$122\rightarrow124$（2），$124\rightarrow183$（59）。总距离$=16+23+51+2+31+24+2+59=208$。

正确答案是C。

工作集是在最近$\Delta$次页面引用中访问的页面集合。在时间$t=10$，最近4次引用是时间7、8、9、10，对应的页面是5、1、2、3。因此工作集为$\{1,2,3,5\}$。

正确答案是C。

在链接分配中，要访问第$i$块，必须从第一块开始依次读取每一块，直到第$i$块。因此访问第500块需要读取前499块才能找到第500块的地址，然后读第500块，但通常读每块都需要一次I/O，所以总共500次磁盘I/O（读第1块到第500块）。

正确答案是A。

图中存在循环等待：P1等待R2（被P2持有），P2等待R1（被P1持有），因此P1和P2之间形成死锁。P3等待R1，但R1被P1持有，而P1是死锁的一部分，因此系统存在死锁。

正确答案是C。

计算各算法缺页次数：FIFO算法缺页9次（具体序列：1,2,3,4,1,2,5,3,4，共9次），所以A错误；LRU算法缺页10次（具体序列：1,2,3,4,1,2,5,3,4,5，共10次），所以B错误；OPT算法缺页7次（具体序列：1,2,3,4,5,3,4，共7次），所以C正确。因此只有C正确。

A. 192.168.0.0/22。

解析：四个地址块的第三个八位组是0、1、2、3，二进制形式为00000000、00000001、00000010、00000011。共同前缀是前22位，因此聚合后的网络是192.168.0.0/22。选项B/23只覆盖192.168.0.0和192.168.1.0，选项C/24是单个网络，选项D/25覆盖范围更小。

A. 立即重传被认为丢失的段。

解析：在TCP快速重传机制中，当收到三个重复的ACK时，发送方会立即重传丢失的段，而不等待重传超时。选项B和C是超时后的行为，选项D不正确，因为只重传丢失的段，而不是所有未确认的段。

C. 递归和迭代查询。

解析：主机向本地DNS服务器发送递归查询（要求本地服务器完成查询），本地DNS服务器然后向根服务器等发送迭代查询（根服务器返回推荐而不是直接答案）。因此，两者都涉及。

A. 64。

解析：以太网帧包括目的MAC地址（6字节）、源MAC地址（6字节）、长度/类型（2字节）、数据（46-1500字节）、FCS（4字节）。所以6+6+2+46+4=64字节。前导码和帧起始定界符是物理层的，不包含在帧大小中。

B. 丢弃该数据包并发送ICMP超时消息。

解析：当TTL为1时，路由器将TTL减1后变为0，因此丢弃该数据包并发送ICMP时间超过消息。选项A和D不正确，因为TTL为0时不能转发。选项C用于重定向，当有更优路径时发送，不适用于TTL过期。

D. 无连接。

解析：UDP是无连接且不可靠的协议，没有流量控制或可靠交付机制。选项A、B、C是TCP的特点。

B. 3。

解析：MTU为1500字节，IP报头为20字节，因此每个分片的数据部分最大为1480字节。原始数据包的数据大小为4000-20=3980字节。第一个分片：20字节报头 + 1480数据，第二个分片：20+1480，第三个分片：20+ (3980-2960)=20+1020=1040字节。所以需要3个分片。

B. 客户端发送ClientHello。

解析：SSL/TLS握手从客户端发送ClientHello开始，其中包括支持的密码套件和随机数等。然后服务器回复ServerHello、证书等。其他选项是后续步骤。

(1) 算法的基本设计思想：
由于需要计算对于每个 i，Ai 与 Aj (0 ≤ j ≤ i) 乘积的最大值，且乘积的最大值取决于 Ai 的符号。当 Ai ≥ 0 时，乘积最大值出现在 Aj 取最大值时；当 Ai < 0 时，乘积最大值出现在 Aj 取最小值时。因此，可以通过动态维护前缀最大值和前缀最小值来高效计算 res[i]。
具体步骤：
- 初始化 res[0] = A[0] × A[0]
- 维护两个变量 maxSoFar 和 minSoFar，分别表示当前的前缀最大值和前缀最小值
- 对于 i 从 1 到 n-1：
  - 更新 maxSoFar = max(maxSoFar, A[i])
  - 更新 minSoFar = min(minSoFar, A[i])
  - 如果 A[i] ≥ 0，则 res[i] = A[i] × maxSoFar
  - 如果 A[i] < 0，则 res[i] = A[i] × minSoFar
此算法通过一次遍历完成计算，时间和空间效率高。

(2) C++ 语言描述算法：
```cpp
void calMulMaxLeft(int A[], int res[], int n) {
    if (n <= 0) return; // 处理空数组情况
    
    // 初始化第一个元素
    res[0] = A[0] * A[0];
    
    if (n == 1) return; // 如果只有一个元素，直接返回
    
    // 初始化前缀最大值和最小值
    int maxSoFar = A[0];
    int minSoFar = A[0];
    
    // 遍历计算每个res[i]
    for (int i = 1; i < n; i++) {
        // 更新前缀最大值和最小值
        if (A[i] > maxSoFar) {
            maxSoFar = A[i];
        }
        if (A[i] < minSoFar) {
            minSoFar = A[i];
        }
        
        // 根据A[i]的符号计算乘积最大值
        if (A[i] >= 0) {
            res[i] = A[i] * maxSoFar;
        } else {
            res[i] = A[i] * minSoFar;
        }
    }
}
```
注释：算法通过动态维护前缀最大值和最小值，避免了使用额外数组，提高了空间效率。关键点在于根据A[i]的符号选择合适的前缀值进行计算。

(3) 时间复杂度和空间复杂度：
- 时间复杂度：算法只需要一次遍历数组，每次操作都是常数时间，因此总时间复杂度为 O(n)。
- 空间复杂度：除了输入输出数组外，只使用了常数个额外变量，因此空间复杂度为 O(1)。

（1）Floyd算法通过动态规划迭代更新距离矩阵。初始距离矩阵D(0)为邻接矩阵：  
D(0) = [  
  [0, 5, ∞, 10],  
  [∞, 0, 3, ∞],  
  [∞, ∞, 0, 1],  
  [∞, ∞, ∞, 0]  
]  
迭代过程如下：  
- k=0（以V0为中间节点）：由于V0只有出边，没有入边，因此D(1)与D(0)相同。  
D(1) = [  
  [0, 5, ∞, 10],  
  [∞, 0, 3, ∞],  
  [∞, ∞, 0, 1],  
  [∞, ∞, ∞, 0]  
]  
- k=1（以V1为中间节点）：更新D[i][j] = min(D[i][j], D[i][1] + D[1][j])。  
  - i=0, j=2: D[0][2] = min(∞, 5+3) = 8  
  - 其他元素不变，因此D(2) = [  
    [0, 5, 8, 10],  
    [∞, 0, 3, ∞],  
    [∞, ∞, 0, 1],  
    [∞, ∞, ∞, 0]  
  ]  
- k=2（以V2为中间节点）：更新D[i][j] = min(D[i][j], D[i][2] + D[2][j])。  
  - i=0, j=3: D[0][3] = min(10, 8+1) = 9  
  - i=1, j=3: D[1][3] = min(∞, 3+1) = 4  
  - 其他元素不变，因此D(3) = [  
    [0, 5, 8, 9],  
    [∞, 0, 3, 4],  
    [∞, ∞, 0, 1],  
    [∞, ∞, ∞, 0]  
  ]  
- k=3（以V3为中间节点）：由于D[3][j]均为∞（j≠3），因此没有更新，D(3)为最终矩阵。  
（2）从V0到V2的最短路径长度为8，路径序列为V0 → V1 → V2。  
（3）Floyd算法能检测到负权环。因为在迭代过程中，如果距离矩阵中对角线元素D[i][i]出现负值，则表示存在经过顶点Vi的负权环，这意味着最短路径无定义。  
解析：Floyd算法通过三重循环迭代更新距离矩阵，每次考虑一个中间节点。对于负权环的检测，算法在迭代后会检查对角线元素，若发现负值则说明有负权环。  

（1）主存地址中Cache组号字段占6位，块内地址字段占7位。虚拟地址中位12~7可作为Cache索引。  
解析：  
- Cache数据区大小为32KB = 32768B，主存块大小为128B，因此Cache总块数 = 32768B / 128B = 256块。  
- 采用4路组相联映射，组数 = 256 / 4 = 64组，因此组号字段占log₂64 = 6位。  
- 主存块大小128B，因此块内地址字段占log₂128 = 7位。  
- 虚拟地址中，页大小为8KB = 8192B，因此页内偏移占log₂8192 = 13位（位12~0）。  
- Cache索引需要6位，且位于页内偏移中，块内地址占位6~0，因此索引占位12~7。  

（2）d[500]的虚拟地址为0200 0810H，对应的Cache组号为16。  
解析：  
- 数组d的起始虚拟地址为0200 0040H，每个int元素占4字节，因此d[500]的地址 = 起始地址 + 500 × 4 = 0200 0040H + 07D0H = 0200 0810H。  
- Cache组号由虚拟地址位12~7决定。地址0200 0810H的页内偏移 = 0200 0810H mod 8KB = 0200 0810H mod 02000H = 0810H。计算虚拟地址：0200 0810H，二进制表示中位12~7。先将地址转换为页内偏移：地址0200 0810H，页大小为8KB，页内偏移为地址低13位。0200 0810H的十进制为33556496，页内偏移 = 33556496 mod 8192 = 2064十进制。2064的二进制为0100000010000b（13位），位12~7为位12=0、位11=1、位10=0、位9=0、位8=0、位7=0，因此二进制010000b = 16十进制。或者直接计算：虚拟地址右移7位（块大小128B）得到块地址，然后模64（组数）得到组号。地址0200 0810H右移7位相当于除以128，33556496 / 128 = 262160，262160 mod 64 = 16。因此组号为16。  

（3）d[0]在其所在主存块内的偏移量为40H；访问数组d的Cache缺失率为3.13%，数组元素的平均访问时间为10.81时钟周期。  
解析：  
- d[0]的虚拟地址为0200 0040H，主存块大小为128B，因此块内偏移 = 地址 mod 128 = 0200 0040H mod 128。0200 0040H的十进制为33554496，33554496 mod 128 = 64十进制，转换为十六进制为40H。  
- 数组d有4096个元素，每个元素占4字节，主存块大小为128B，因此每个主存块包含的元素数 = 128B / 4B = 32个。  
- 对于顺序访问数组d的读操作（假设主要考虑读访问），每个块的第一次访问会发生Cache缺失，因此缺失率 = 1 / 32 = 0.03125 = 3.125%，保留两位小数为3.13%。  
- 平均访问时间 = 命中时间 + 缺失率 × 缺失损失 = 3 + 0.03125 × 250 = 3 + 7.8125 = 10.8125时钟周期，保留两位小数为10.81周期。  
- 注：这里假设访问数组d主要指读访问，写访问假设命中且忽略写时间，与参考题风格一致。  

（4）数组d分布在3个页中；访问数组d所引起的缺页次数为3次。  
解析：  
- 计算：起始地址0200 0040H，页边界为0200 0000H~0200 1FFFH（第一页）、0200 2000H~0200 3FFFH（第二页）、0200 4000H~0200 5FFFH（第三页）。数组从0200 0040H到0200 0040H+16384-1=0200 403FH。因此覆盖第一页（0040H~1FFFH）、第二页（2000H~3FFFH）、第三页（4000H~403FH），故分布在3个页中。  
- 由于数组d未调入主存，顺序访问时，每次访问新页会发生缺页，因此缺页次数为3次。  

（1）组号字段6位和块内地址字段7位各1分，虚拟索引位12~7得1分。  
（2）虚拟地址0200 0810H得1分，Cache组号16得1分。  
（3）d[0]偏移量40H得1分，Cache缺失率3.13%得2分，平均访问时间10.81周期得2分。  
（4）数组分布在3页得1分，缺页次数3次得1分。

（1）  
- 寄存器 R、Q 和 Y 的初始内容：  
  - R 初始为被除数的高位部分，即 R0 的内容。由于 d[i]=0xABCD1234（32位有符号数，最高位为1），符号扩展后 R0=0xFFFFFFFF，因此 R=0xFFFFFFFF。  
  - Q 初始为被除数的低位部分，即 R1 的内容，因此 Q=0xABCD1234。  
  - Y 初始为除数，即 R2 的内容 x=0x80，扩展为32位后 Y=0x00000080。  
- 图中包含计数器的部件是控制器。  
- 由 ALUop 所控制的 ALU 运算有2种：加法和减法。  

（2）  
- 发生除法异常的情况：  
  ① 除数为零：当 x=0x00000000 时（此时 d[i] 可为任意32位有符号数，例如 d[i]=0xABCD1234），会触发除法异常；  
  ② 商溢出：当 d[i]=0x80000000（32位有符号最小负数）且 x=0xFFFFFFFF（除数为-1）时，商为2³¹，超出32位有符号数的表示范围（[-2³¹, 2³¹-1]），会触发除法异常。  
- 发生除法异常时，在异常响应过程中 CPU 需要完成的操作：  
  - 保存当前程序计数器（PC）、程序状态字（PSW）及通用寄存器等上下文信息到堆栈或特定存储区域；  
  - 设置异常类型码以标识除法异常；  
  - 将程序计数器（PC）更新为除法异常处理程序的入口地址；  
  - 切换CPU特权级（如从用户态切换到内核态），开始执行异常处理程序。  

评分标准  
（1）共6分：  
- R、Q、Y 的初始内容各1分，共3分。正确写出十六进制值：R=0xFFFFFFFF, Q=0xABCD1234, Y=0x00000080。  
- 包含计数器的部件：控制器，1分。  
- ALU运算种类：2种（加法和减法），2分。  

（2）共5分：  
- 除法异常情况：指出除数为零（x=0x00000000，d[i]为任意32位值），1分；指出商溢出场景（d[i]=0x80000000且x=0xFFFFFFFF），2分；  
- 异常响应操作：保存上下文（PC、PSW等），1分；加载处理程序地址并切换特权级，1分。  

定义以下信号量：  
- S1：表示可收集日志的空位数量，初始值为4。当S1>0时，收集者可以收集日志；当S1=0时，收集者必须等待（此时未分析日志数为4，满足小于5的条件）。  
- S2：表示未分析日志的数量，初始值为0。当S2>0时，分析者可以取日志分析；当S2=0时，分析者必须等待。  
- S3：表示已分析日志的数量，初始值为0。当S3>0时，存储者可以取日志存储；当S3=0时，存储者必须等待。  

同步代码：  
收集者进程：  
```  
while (true) {  
    wait(S1);  
    // 收集日志  
    signal(S2);  
}  
```  
分析者进程：  
```  
while (true) {  
    wait(S2);  
    // 分析日志（使用分析工具）  
    signal(S3);  
}  
```  
存储者进程：  
```  
while (true) {  
    wait(S3);  
    // 存储日志（使用存储设备）  
    signal(S1);  
}  
```  
解析：  
- 收集者通过wait(S1)检查是否可收集日志（S1初始4，表示最多4个未分析日志，满足小于5的限制），收集后通过signal(S2)增加未分析日志数。  
- 分析者通过wait(S2)等待未分析日志，获取日志后使用分析工具进行分析，分析完成后通过signal(S3)增加已分析日志数。  
- 存储者通过wait(S3)等待已分析日志，获取日志后使用存储设备进行存储，存储完成后通过signal(S1)释放空位，使收集者可以继续收集。  
- 信号量S1、S2、S3用于同步流程，确保日志处理按“收集→分析→存储”的顺序进行，且满足未分析日志数量不超过4（小于5）的限制，同时因分析工具仅由分析者使用、存储设备仅由存储者使用，无需额外互斥信号量，符合“尽可能少的信号量”要求。  

（1）进程控制块（PCB，Linux下对应`task_struct`结构）位于内核区。因为PCB是操作系统内核用于管理进程和线程的数据结构，存储在操作系统内核的地址空间中。当write_thread线程执行write系统调用时，该线程会从用户态切换到内核态；对于普通文件的缓冲写（如代码中未指定O_SYNC等同步标志），数据通常被复制到内核页缓存后立即返回，线程处于运行状态（就绪或执行）；如果写入操作需要等待I/O完成（如同步I/O、慢速设备或内核缓冲区已满等情况），线程会进入阻塞状态（睡眠状态），直到I/O操作完成。

（2）main函数和write_thread函数的代码位于只读代码段（或文本段）。因为代码是只读的，在程序加载时被映射到虚拟地址空间的代码区域。write函数调用时，需要通过执行驱动程序实现的操作包括：①文件系统驱动程序：处理文件元数据（如inode更新）、页缓存管理、路径解析等逻辑；②块设备驱动程序：控制硬件设备（如磁盘）进行数据读写。这些驱动程序是操作系统内核的一部分，负责衔接文件系统与硬件。

（3）变量buffer是未显式初始化的全局数组，被分配在BSS段（未初始化数据段，广义上也属于数据段范畴）；open函数返回的文件描述符fd是write_thread函数中的局部变量，被分配在用户栈（或栈区）。如果多个线程同时写入同一个文件而没有同步，写操作非原子性且文件指针为进程共享资源，会导致数据竞争问题，具体表现为：①数据交织：不同线程写入的数据交替出现，如线程A写入"abc"与线程B写入"def"可能产生"adbecf"等错乱形式；②数据覆盖：由于文件指针竞争，部分数据可能被其他线程的写入覆盖，导致内容不完整；③文件元数据不一致：多个线程同时更新文件大小等元数据可能造成逻辑错误。

解析：
- 问题（1）考查进程/线程控制块的存储位置和线程状态转换。PCB（`task_struct`）在内核区是标准知识；write系统调用的状态需区分缓冲I/O与同步I/O场景，普通文件的缓冲写通常不会阻塞线程，但在特定条件下可能阻塞。
- 问题（2）考查代码段属性和系统调用的底层实现。代码段只读；write操作依赖文件系统驱动管理逻辑层、块设备驱动负责硬件交互，二者共同完成文件写入。
- 问题（3）考查内存区域分配和同步问题。未初始化全局变量/数组属于BSS段，局部变量在栈；文件写入缺乏同步时，文件指针的共享性会加剧竞争条件，引发数据交织、覆盖和元数据不一致等具体错乱现象。

评分标准：
- （1）PCB位置（含Linux下`task_struct`补充说明）正确得1分，线程状态结合I/O类型描述正确（包括运行和阻塞两种状态）得1分。
- （2）代码区域正确得1分，write操作涉及的驱动程序部分（文件系统驱动和块设备驱动）各得1分。
- （3）buffer区域（BSS段/数据段）正确得1分，文件描述符区域正确得1分，同步问题描述出具体错乱现象（含文件指针共享的补充）得1分。

（1）  
- 单向传播时延：传播时延 = 距离 / 传播速度 = 4000 km / 200,000 km/s = 0.02 s = 20 ms。  
- 最大吞吐量：由于忽略协议开销，最大吞吐量等于链路带宽，即100 Mb/s。  
- 文件传输时间：文件大小8000 B = 64000 b，传输时间（数据加载到链路的时间）= 文件大小 / 吞吐量 = 64000 b / 100 Mb/s = 64000 b / 100,000,000 b/s = 0.00064 s = 0.64 ms。忽略首部开销和以太网传播时延，但需计入光纤链路的单向传播时延（信号从R1传到R2的耗时），因此总时间 = 传输时间 + 单向传播时延 = 0.64 ms + 20 ms = 20.64 ms，即至少需要20.64 ms。  

（2）  
- 帧传输时间 T_t = 帧长 / 数据速率 = 1500 B / 100 Mb/s = 12000 b / 100,000,000 b/s = 0.00012 s = 0.12 ms。  
- 传播时延 T_p = 20 ms = 0.02 s。  
- 对于GBN协议，信道利用率 η = W × T_t / (T_t + 2 × T_p)，其中 W 为发送窗口大小。  
- 要求 η ≥ 90%，即 W × 0.00012 / (0.00012 + 2 × 0.02) ≥ 0.9。  
- 计算分母：T_t + 2 × T_p = 0.00012 + 0.04 = 0.04012 s。  
- 因此 W ≥ 0.9 × 0.04012 / 0.00012 ≈ 0.9 × 334.333 ≈ 300.9，取整 W ≥ 301。  
- 序号字段位数 k：对于GBN，发送窗口大小 W ≤ 2^k - 1，因此 2^k - 1 ≥ 301。  
- 2^8 = 256 < 301，2^9 = 512 ≥ 301，所以 k = 9 位。  

（3）  
- IP地址空间 192.168.1.0/24，可分配地址范围为 192.168.1.1 - 192.168.1.254。  
- 办公区子网需要不少于100个IP地址，因此主机位至少7位（2^7 - 2 = 126 ≥ 100），子网掩码为/25，子网地址为 192.168.1.0/25。 
- 剩余地址空间为 192.168.1.128/25，需要划分为两个子网各不少于50个IP地址。  
- 每个子网需要主机位至少6位（2^6 - 2 = 62 ≥ 50），子网掩码为/26。  
- 宿舍区子网地址为 192.168.1.128/26，生产区子网地址为 192.168.1.192/26。