# 计算机组成原理_工程实践

**Repository Path**: yy_lan/cs

## Basic Information

- **Project Name**: 计算机组成原理_工程实践
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 41
- **Created**: 2025-05-11
- **Last Updated**: 2025-06-16

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 《计算机组成与结构》实践项目 — 总体说明

## 📅 项目基本信息

* **提交截止日期**：6月15日 12：00
* **报告时间及方式**：另行通知
* **小组人数**：每组最多3人（自由组队）
* **编程语言**：C语言（基于Windows控制台，无GUI）（建议使用Dev-C++）
* **提交方式**：打包提交代码文件（`.c`、`.h`）、可执行文件、项目说明文档（md格式或pdf格式）
* **提交通道**：另行通知
* **选题方式**：自由组队后，在共享文档中进行选题，每组选择1个题目，题目禁止重复选择。
* **注意事项**：如果对题目本身存在疑问，可以在课程群中提出。除此之外助教不会回答任何技术相关的问题，请大家自行解决，培养工程思维和Debug能力。

---

## 📦 提交内容要求

每组需提交以下材料：

1. `main.c`（主程序代码）及必要的头文件；
2. `README.md` 或说明文档（PDF），包括：
   * 项目简介与功能描述；
   * 核心设计结构说明；
   * 各成员分工情况；
   * 编译运行方法说明；
3. 可执行程序（Windows平台下可运行）；
4. 示例输入输出截图；
5. 项目源代码中需含必要注释，结构清晰。

---

## 🎯 评分方式（总分 100 分）

| 评分维度       | 权重   | 说明                     |
| ---------- | ---- | ---------------------- |
| 功能正确性      | 50 分 | 是否完成全部基本功能，运行无误，符合题目要求 |
| 程序结构与可读性   | 20 分 | 代码风格统一，模块划分清晰，有适当注释    |
| 扩展与挑战部分完成度 | 20 分 | 是否实现附加功能或难度加分点         |
| 项目说明文档     | 10 分 | 说明是否详尽、格式规范、结构完整       |

> 📌 注：如发现雷同、抄袭或未遵守“禁止调用现成函数”说明的行为，将严肃处理。

---

## 📋 项目题目列表（共30题）

> 📌 注：如果你对下方题目都不满意，可以自己提出课题与助教沟通，确认可用后做自己提出的课题。

| 编号 | 题目名称                | 难度 |
| -- | ------------------- | -- |
| 01 | 模拟二进制加法器            | 入门 |
| 02 | 寄存器组模拟器            | 入门 |
| 03 | ALU算术逻辑单元仿真        | 入门 |
| 04 | 十进制转二进制转换器        | 入门 |
| 05 | 指令译码器实现            | 入门 |
| 06 | 主存访问模拟器            | 入门 |
| 07 | 逻辑门电路模拟器          | 入门 |
| 08 | 字符与ASCII编码器         | 入门 |
| 09 | 简易程序计数器模拟器        | 入门 |
| 10 | 内存与寄存器交换模拟器       | 入门 |
| 11 | 浮点数二进制表示器         | 入门 |
| 12 | 反向地址访问模拟器         | 入门 |
| 13 | 数值位翻转器             | 入门 |
| 14 | 奇偶校验位计算器          | 入门 |
| 15 | 补码转换器              | 入门 |
| 16 | 十六进制计算器           | 入门 |
| 17 | 简单缓存访问模拟器         | 入门 |
| 18 | 内存对齐检测器           | 入门 |
| 19 | 32位浮点数解析器（IEEE 754） | 中等 |
| 20 | 虚拟地址页表转换模拟器       | 中等 |
| 21 | 管线冲突检测模拟器         | 中等 |
| 22 | 简易微程序控制器模拟        | 中等 |
| 23 | 定点乘法器（Booth算法）     | 中等 |
| 24 | 四路组相联缓存模拟器        | 中等 |
| 25 | 寄存器组模拟器            | 中等 |
| 26 | 算术逻辑单元（ALU）模拟器   | 中等 |
| 27 | 简化版 MIPS 解释器        | 稍高 |
| 28 | 五级流水线执行器模拟（带冒泡插入） | 稍高 |
| 29 | 两级缓存一致性模拟器（MESI 协议） | 稍高 |
| 30 | 微型指令集架构设计与解释器实现     | 稍高 |

---

## **项目 1：模拟二进制加法器**

### 🔧 功能要求：

* 实现两个 **4位二进制数** 的逐位加法。
* 每一位加法需要显示进位过程。
* 所有计算必须基于位运算完成，**禁止使用C语言内置整数加法运算符（+）**。

### 🔤 输入输出样例：

```
Input A: 1011  
Input B: 1101  

Output:  
Bit 0: 1 + 1 with carry 0 => sum: 0 carry: 1  
Bit 1: 1 + 0 with carry 1 => sum: 0 carry: 1  
Bit 2: 0 + 1 with carry 1 => sum: 0 carry: 1  
Bit 3: 1 + 1 with carry 1 => sum: 1 carry: 1  
Final Sum: 11000
```

### 👥 工作分工建议：

* 成员A：输入/输出模块设计和错误检测。
* 成员B：逐位加法逻辑实现。
* 成员C：结果整合、调试与测试脚本编写。

### 📝 评分标准：

* 功能正确性（40%）
* 位运算实现完整性（30%）
* 输入格式与边界情况处理（15%）
* 程序结构清晰度与注释质量（15%）

---

## **项目 2：寄存器组模拟器**

### 🔧 功能要求：

* 模拟8个通用寄存器（R0–R7），每个32位。
* 支持命令行输入格式：`WRITE Rx value`、`READ Rx`、`DUMP`
* 所有寄存器初始值为0。

### 🔤 输入输出样例：

```
> WRITE R2 15  
> READ R2  
R2 = 15  

> DUMP  
R0 = 0  
R1 = 0  
R2 = 15  
...  
R7 = 0
```

### 👥 工作分工建议：

* 成员A：数据结构与寄存器初始化。
* 成员B：命令解析与执行逻辑。
* 成员C：输出格式、调试与边界情况处理。

### 📝 评分标准：

* 指令处理正确率（40%）
* 存储结构设计合理性（25%）
* 交互友好性和边界处理（20%）
* 注释与程序可读性（15%）

---

## **项目 3：ALU算术逻辑单元仿真**

### 🔧 功能要求：

* 支持以下运算：ADD, SUB, AND, OR, XOR, NOT
* 操作数为8位整数，结果输出为二进制字符串
* **不得使用标准库中的`+`、`-`、`*`等运算符（必须使用位运算模拟）**

### 🔤 输入输出样例：

```
Input: 5 AND 3  
Binary: 00000101 AND 00000011  
Result: 00000001

Input: NOT 6  
Binary: NOT 00000110  
Result: 11111001
```

### 👥 工作分工建议：

* 成员A：输入解析与操作符识别。
* 成员B：逻辑运算模块（基于位运算）。
* 成员C：格式化输出、异常处理与调试。

### 📝 评分标准：

* 运算功能实现正确（40%）
* 位运算实现方式规范（30%）
* 输出格式标准化（15%）
* 注释与模块划分合理（15%）

---

## **项目 4：十进制转二进制转换器**

### 🔧 功能要求：

* 将一个带符号的十进制整数转换为8位补码形式的二进制字符串。
* 结果应带符号位，范围\[-128, 127]
* 禁止使用`itoa`、`sprintf`等字符串转换函数。

### 🔤 输入输出样例：

```
Input: -5  
Output: 11111011  

Input: 15  
Output: 00001111
```

### 👥 工作分工建议：

* 成员A：输入验证与符号判断。
* 成员B：补码计算逻辑（特别是负数处理）。
* 成员C：结果拼接与调试。

### 📝 评分标准：

* 补码转换正确性（40%）
* 字符串构造过程合规性（25%）
* 输入范围校验与报错机制（20%）
* 结构清晰与注释完整性（15%）

---

## **项目 5：指令译码器实现**

### 🔧 功能要求：

实现一个简化的指令译码器，解析输入的16位二进制字符串形式的指令，并输出各字段的含义。具体要求如下：

1. **输入格式**：
   * 输入为一个16位的二进制字符串（如 `0001001010001100`）。
   * 字符串必须严格为16位，且仅包含字符 `0` 和 `1`。
   * 如果输入不合法（如长度不足或包含非法字符），需提示用户重新输入。

2. **指令格式**：
   * **操作码（Opcode）**：前4位（bit 0-3），表示操作类型。
   * **源寄存器（Src Register）**：接下来的4位（bit 4-7），表示源寄存器编号。
   * **目标寄存器（Dst Register）**：再接下来的4位（bit 8-11），表示目标寄存器编号。
   * **立即数（Immediate Value）**：最后4位（bit 12-15），表示一个无符号整数。

3. **输出格式**：
   * 操作码（Opcode）：显示二进制值及对应的操作名称（如 `0001 (ADD)`）。
   * 源寄存器（Src）：显示寄存器编号（如 `R2`）。
   * 目标寄存器（Dst）：显示寄存器编号（如 `R8`）。
   * 立即数（Immediate）：显示十进制值（如 `12`）。

4. **操作码定义**：
   * `0001`：ADD（加法）
   * `0010`：SUB（减法）
   * `0011`：AND（按位与）
   * `0100`：OR（按位或）
   * `0101`：XOR（按位异或）
   * `0110`：LOAD（加载）
   * `0111`：STORE（存储）
   * 其他值：非法操作码，需提示用户。

### 🔤 输入输出样例：

```
Input: 0001001010001100  
Output:  
Opcode: 0001 (ADD)  
Src: R2  
Dst: R8  
Immediate: 12
```

### 👥 工作分工建议：

* 成员A：定义指令格式及合法性检查。
* 成员B：字符串解析与字段分割。
* 成员C：解释输出与用户提示。

### 📝 评分标准：

* 字段解析准确性（40%）
* 译码规则清晰规范（30%）
* 输出整洁明了（15%）
* 程序结构与注释（15%）

---

## **项目 6：主存访问模拟器**

### 🔧 功能要求：

* 模拟一段主存（256字节），按地址访问读/写操作。
* 命令格式：`WRITE <address> <value>`、`READ <address>`
* 地址合法性需判断，支持`DUMP`内存状态。
* 禁止使用数组以外的任何高阶数据结构（如链表、库容器等）

### 🔤 输入输出样例：

```
> WRITE 10 255  
> READ 10  
Memory[10] = 255  

> DUMP  
Memory[0] = 0  
...  
Memory[10] = 255  
...  
Memory[255] = 0
```

### 👥 工作分工建议：

* 成员A：内存结构初始化与边界检测。
* 成员B：命令解析与读写逻辑。
* 成员C：结果打印模块与调试工具。

### 📝 评分标准：

* 读写操作正确性（40%）
* 边界处理与错误提示（30%）
* 数据结构实现合理性（15%）
* 程序风格与注释（15%）

---

## **项目 7：逻辑门电路模拟器**

### 🔧 功能要求：

* 使用C语言模拟基础逻辑门：AND、OR、NOT、NAND、NOR、XOR。
* 用户可输入任意两个1位二进制数和运算类型，程序返回结果。
* **不得使用`&&`、`||`等逻辑运算符，必须使用位运算（`&`, `|`, `^`, `~`）实现逻辑门功能。**

### 🔤 输入输出样例：

```
Input A: 1
Input B: 0 
Operation: NAND  
Result: 1
```

### 👥 工作分工建议：

* 成员A：输入校验与运算类型解析。
* 成员B：逻辑门功能实现。
* 成员C：结构整理与交互界面。

### 📝 评分标准：

* 运算功能准确（40%）
* 禁止逻辑运算符执行情况（检查实现）（25%）
* 用户输入与输出设计（20%）
* 注释与代码结构清晰（15%）

---

## **项目 8：字符与ASCII编码器**

### 🔧 功能要求：

* 用户输入字符串，程序逐字符显示其ASCII值（二进制和十进制）。
* 程序必须实现十进制到二进制转换，**禁止使用`itoa`、`sprintf`等字符串转换函数。**

### 🔤 输入输出样例：

```
Input: Hello  
Output:  
H => ASCII: 72 => Binary: 01001000  
e => ASCII: 101 => Binary: 01100101  
...
```

### 👥 工作分工建议：

* 成员A：字符读取与控制流程。
* 成员B：十进制转二进制函数实现。
* 成员C：格式化输出。

### 📝 评分标准：

* 编码提取正确（40%）
* 二进制转换函数实现规范（30%）
* 输出可读性（15%）
* 程序注释与格式规范（15%）

---

## **项目 9：简易程序计数器模拟器**

### 🔧 功能要求：

* 模拟一个8位程序计数器（PC），支持指令：INC、DEC、RESET、SET <value>
* 初始值为0，每次操作后显示当前PC值（二进制与十进制）。

### 🔤 输入输出样例：

```
> INC  
PC = 00000001 (1)  
> SET 5  
PC = 00000101 (5)  
> DEC  
PC = 00000100 (4)
```

### 👥 工作分工建议：

* 成员A：计数器结构设计。
* 成员B：指令解析与执行逻辑。
* 成员C：输出格式、测试脚本编写。

### 📝 评分标准：

* 功能正确实现（40%）
* 指令处理逻辑清晰（30%）
* 输出直观、格式统一（15%）
* 注释与模块化程度（15%）

---

## **项目 10：内存与寄存器交换模拟器**

### 🔧 功能要求：

* 模拟一个寄存器（R）和一段内存（64字节），支持命令：

  * `LOAD <address>`：将内存地址的数据读入寄存器
  * `STORE <address>`：将寄存器值写入内存地址
* 寄存器和内存初始值均为0。

### 🔤 输入输出样例：

```
> STORE 10  
Memory[10] = 0  
> LOAD 20  
Register = 0  
> STORE 20  
Memory[20] = 0
```

### 👥 工作分工建议：

* 成员A：寄存器和内存结构实现。
* 成员B：命令解析与地址判断。
* 成员C：调试与用户提示实现。

### 📝 评分标准：

* 数据交换功能正确（40%）
* 地址范围控制与异常处理（30%）
* 数据一致性检查机制（15%）
* 程序结构清晰度（15%）

---

## **项目 11：浮点数二进制表示器**

### 🔧 功能要求：

* 输入一个`float`类型变量，程序打印其IEEE 754单精度二进制表示（32位）。
* 需将float转换为二进制格式，显示符号位、指数部分和尾数部分。
* **不得使用联合体（union）或标准库强制转换函数。**

### 🔤 输入输出样例：

```
Input: 3.75  
Output:  
Sign: 0  
Exponent: 10000000  
Mantissa: 11100000000000000000000
```

### 👥 工作分工建议：

* 成员A：浮点数转内存位分析设计。
* 成员B：位提取函数实现。
* 成员C：结果输出排版与测试。

### 📝 评分标准：

* IEEE格式正确提取（40%）
* 禁用union或库函数检查（25%）
* 输出格式完整（20%）
* 注释与代码结构（15%）

---

## **项目 12：反向地址访问模拟器**

### 🔧 功能要求：

* 用户输入一个正整数数组（最大10个元素），程序逆序打印数组内容，并输出其每个元素在内存中的地址。
* 必须使用指针进行访问与地址获取，**禁止使用下标（array\[i]）语法。**

### 🔤 输入输出样例：

```
Input: 1 2 3 4 5  
Output:  
5 at address 0x123456  
4 at address 0x123454  
...  
1 at address 0x12344C
```

### 👥 工作分工建议：

* 成员A：数组输入与存储。
* 成员B：指针逆序访问实现。
* 成员C：地址打印与输出排版。

### 📝 评分标准：

* 指针操作是否正确（40%）
* 逆序与地址对应关系准确（30%）
* 禁用数组下标实现检查（15%）
* 注释与结构整洁性（15%）

---

## **项目 13：数值位翻转器**

### 🔧 功能要求：

* 输入一个正整数（32位以内），程序将其二进制表示中的每一位进行翻转（0→1，1→0），并输出结果的十进制与二进制形式。
* 禁止使用现成的位反转函数，需自行实现。

### 🔤 输入输出样例：

```
Input: 5  
Binary: 00000000000000000000000000000101  
Flipped: 11111111111111111111111111111010  
Decimal Result: 4294967290
```

### 👥 工作分工建议：

* 成员A：输入读取与格式控制。
* 成员B：位翻转函数实现。
* 成员C：二进制显示函数。

### 📝 评分标准：

* 位翻转准确性（40%）
* 二进制格式化输出（30%）
* 输入边界处理（15%）
* 注释与模块划分（15%）

---

## **项目 14：奇偶校验位计算器**

### 🔧 功能要求：

* 输入一个8位二进制字符串（如 "10101010"），程序输出其奇校验位和偶校验位。
* 奇校验：若1的个数为奇数，则校验位为0；为偶数，则为1（使整体为奇数个1）。
* 偶校验则反之。

### 🔤 输入输出样例：

```
Input: 11010010  
Odd Parity Bit: 1  
Even Parity Bit: 0
```

### 👥 工作分工建议：

* 成员A：输入合法性判断。
* 成员B：1的位计数函数。
* 成员C：输出与验证格式。

### 📝 评分标准：

* 校验位逻辑正确（40%）
* 输入判断与纠错机制（30%）
* 输出规范与测试覆盖（15%）
* 模块结构与注释清晰（15%）

---

## **项目 15：补码转换器**

### 🔧 功能要求：

* 输入一个范围在\[-128, 127]的整数，程序输出其8位补码表示。
* 要求手动实现补码生成逻辑（尤其对负数处理），禁止调用标准库的位运算封装函数。

### 🔤 输入输出样例：

```
Input: -5  
Output: 11111011
```

### 👥 工作分工建议：

* 成员A：正负数识别与控制逻辑。
* 成员B：补码构造实现。
* 成员C：二进制输出格式控制。

### 📝 评分标准：

* 补码生成是否准确（40%）
* 负数边界值处理（30%）
* 输出整洁性（15%）
* 结构化与注释（15%）

---

## **项目 16：十六进制计算器**

### 🔧 功能要求：

* 用户输入两个十六进制数（如`0x1F`, `0xA3`）与一个运算符（+、-、\*、/）。
* 输出十进制结果与十六进制结果。
* 必须实现十六进制输入解析与输出格式控制。

### 🔤 输入输出样例：

```
Input: 0x1F + 0xA3  
Decimal Result: 190  
Hex Result: 0xBE
```

### 👥 工作分工建议：

* 成员A：输入解析（带0x前缀）；
* 成员B：基本运算实现；
* 成员C：输出格式（十进制和十六进制）封装。

### 📝 评分标准：

* 运算结果准确（40%）
* 十六进制解析与输出格式规范（30%）
* 输入容错处理（15%）
* 模块与注释（15%）

---

## **项目 17：简单缓存访问模拟器**

### 🔧 功能要求：

* 模拟一个包含**8组**缓存行的直接映射Cache（地址范围0\~255）。
* 输入访问地址，输出其是否命中缓存（命中/不命中），以及所在缓存行编号。
* 每组缓存记录最后一次访问地址。

### 🔤 输入输出样例：

#### 示例 1：
```
Access Address: 34  
Cache Line: 2 => Miss  
Updated Cache Line 2: Address 34
Access Address: 34  
Cache Line: 2 => Hit
```

### 👥 工作分工建议：

* 成员A：地址映射到行的哈希函数；
* 成员B：缓存数据结构设计；
* 成员C：访问流程与命中判断逻辑。

### 📝 评分标准：

* 命中判断准确（40%）
* 缓存行编号逻辑正确（30%）
* 输出与用户交互（15%）
* 注释与逻辑结构（15%）

---

## **项目 18：内存块对齐分析器**

### 🔧 功能要求：

实现一个程序，分析用户输入的内存块是否满足指定的对齐要求，并提供优化建议。

1. **对齐检测**：
   * 用户输入一个内存块的起始地址和大小（字节数）。
   * 检测该内存块是否满足以下对齐要求：
     - **4字节对齐**：起始地址能被4整除。
     - **8字节对齐**：起始地址能被8整除。
     - **16字节对齐**：起始地址能被16整除。

2. **优化建议**：
   * 如果内存块不满足对齐要求，提示需要调整的偏移量以满足对齐要求。
   * 输出调整后的起始地址。

3. **输入要求**：
   * 用户输入起始地址和大小，均为非负整数（假设地址范围为32位无符号整数，0~4294967295）。
   * 如果输入非法（如负数或非数字），提示用户重新输入。

4. **输出要求**：
   * 对每种对齐要求，输出“是”或“否”。
   * 如果不满足对齐要求，输出建议的调整值。

### 🔤 输入输出样例：

#### 示例 1：
```
Input Start Address: 100  
Input Block Size: 50  
4-byte aligned: Yes  
8-byte aligned: No  
16-byte aligned: No  
Suggested Adjustment: Start Address +4 (to 104)
```

#### 示例 2：
```
Input Start Address: 64  
Input Block Size: 128  
4-byte aligned: Yes  
8-byte aligned: Yes  
16-byte aligned: Yes
Suggested Adjustment: None
```

### 👥 工作分工建议：

* 成员A：输入校验与读取；
* 成员B：对齐判断逻辑（使用位与）；
* 成员C：输出结果格式与测试用例。

### 📝 评分标准：

* 判断逻辑是否使用位运算（40%）
* 输出结果准确（30%）
* 程序可拓展性与结构（15%）
* 注释与整洁性（15%）

---

## **项目 19：32位浮点数解析器（IEEE 754）**

### 🔧 功能要求：

* 输入一个 32 位无符号整数（如：`0x40490FDB`），将其解释为 IEEE 754 标准的单精度浮点数。
* 显示其符号位、阶码（偏移）、尾数（含隐藏位）、最终十进制值。
* 禁止使用 `float` 或 `union` 转换方式，必须使用位运算进行解析。

### 🔤 输入输出样例：

```
Input: 0x40490FDB  
Sign Bit: 0  
Exponent (biased): 128  
Exponent (actual): 1  
Mantissa: 1.10010010000111111011011  
Decimal Value: 3.14159
```

### 👥 工作分工建议：

* 成员A：输入转换与合法性判断；
* 成员B：位解析与字段提取；
* 成员C：十进制浮点值构造。

### 📝 评分标准：

* 位域提取准确（30%）
* 十进制转换逻辑清晰（30%）
* 禁用 `float` / `union` 实现（20%）
* 模块化与注释（20%）

---

## **项目 20：虚拟地址页表转换模拟器**

### 🔧 功能要求：

* 模拟一个简化的页式虚拟存储系统（假设页大小为 4KB，地址空间为 16-bit 虚拟地址）。
* 输入一个虚拟地址，输出其页号、页内偏移，并模拟转换为物理地址（通过给定页表映射）。
* 要求自行设计页表结构，不得使用数组下标做指针偏移。

### 🔤 输入输出样例：

```
Input Virtual Address: 0x2A3F  
Page Number: 10  
Offset: 0x03F  
Mapped Frame: 5  
Physical Address: 0x53F
```

### 👥 工作分工建议：

* 成员A：地址拆解与位运算；
* 成员B：页表结构与映射模拟；
* 成员C：用户输入与输出解析。

### 📝 评分标准：

* 页号和偏移计算准确（30%）
* 页表映射逻辑正确（30%）
* 地址转换结果正确（20%）
* 程序结构清晰（20%）

---

## **项目 21：管线冲突检测模拟器**

### 🔧 功能要求：

实现一个简化的五级指令流水线模拟器，支持以下功能：

1. **流水线结构**：
   * 模拟五级流水线：`IF`（取指令）、`ID`（指令译码）、`EX`（执行）、`MEM`（访存）、`WB`（写回）。
   * 每条指令依次经过流水线的五个阶段。

2. **冲突检测**：
   * 输入一组指令序列（如 `LOAD R1, 0(R2)`，`ADD R3, R1, R4` 等）。
   * 检测指令之间是否存在数据冒险（RAW，Read After Write）。
   * 如果存在冲突，输出冲突的指令编号及冲突类型。

3. **冒泡插入**：
   * 对于检测到的冲突，模拟插入 `NOP` 指令（冒泡）以解决冲突。
   * 输出插入 `NOP` 后的流水线执行顺序。

4. **输出要求**：
   * 输出每条指令的流水线执行过程（如 Gantt 图样式）。
   * 输出冲突检测结果和插入 `NOP` 后的流水线状态。

### 🔤 输入输出样例：

#### 示例 1（无冲突）：
```
Input Instructions:  
1. LOAD R1, 0(R2)  
2. ADD R3, R4, R5  

Output:  
No conflicts detected.  

Pipeline Execution:  
Cycle 1: LOAD (IF)  
Cycle 2: LOAD (ID), ADD (IF)  
Cycle 3: LOAD (EX), ADD (ID)  
Cycle 4: LOAD (MEM), ADD (EX)  
Cycle 5: LOAD (WB), ADD (MEM)  
Cycle 6: ADD (WB)
```

#### 示例 2（有冲突）：
```
Input Instructions:  
1. LOAD R1, 0(R2)  
2. ADD R3, R1, R4  
3. SUB R5, R3, R6  

Output:  
Conflict Detected:  
- Between Instruction #1 and #2 (RAW on R1)  
- Between Instruction #2 and #3 (RAW on R3)  

Pipeline Execution (with NOPs):  
Cycle 1: LOAD (IF)  
Cycle 2: LOAD (ID), NOP (IF)  
Cycle 3: LOAD (EX), NOP (ID)  
Cycle 4: LOAD (MEM), ADD (IF)  
Cycle 5: LOAD (WB), ADD (ID), NOP (IF)  
Cycle 6: ADD (EX), NOP (ID)  
Cycle 7: ADD (MEM), SUB (IF)  
Cycle 8: ADD (WB), SUB (ID)  
Cycle 9: SUB (EX)  
Cycle 10: SUB (MEM)  
Cycle 11: SUB (WB)
```

### 👥 工作分工建议：

* 成员A：指令数据结构设计；
* 成员B：冲突检测算法；
* 成员C：输出格式与冒泡插入模拟。

### 📝 评分标准：

* 冲突检测逻辑正确（40%）
* 插入冒泡判断正确（30%）
* 指令输入/格式正确（15%）
* 模块注释与代码可读性（15%）

---

## **项目 22：简易微程序控制器模拟**

### 🔧 功能要求：

实现一个简易微程序控制器模拟器，支持以下功能：

1. **微程序控制器结构**：
   * 模拟一个微程序控制器，包含以下核心组件：
     - **微程序存储器（Microprogram ROM）**：存储微指令序列。
     - **控制信号生成器**：根据微指令生成控制信号。
     - **状态寄存器**：记录当前微指令的执行状态。
   * 每条机器指令由一组微指令组成，微指令按时序依次执行。

2. **指令集说明**：
   * 支持以下有限指令集：
     - `LOAD R1, Addr`：从内存地址 `Addr` 加载数据到寄存器 `R1`。
     - `STORE R1, Addr`：将寄存器 `R1` 的数据存储到内存地址 `Addr`。
     - `ADD R1, R2`：将寄存器 `R1` 和 `R2` 的值相加，结果存入 `R1`。
     - `SUB R1, R2`：将寄存器 `R1` 减去 `R2` 的值，结果存入 `R1`。
     - `JUMP Addr`：跳转到指定的内存地址 `Addr`。
   * 每条指令对应一组微操作序列。

3. **微指令执行**：
   * 输入一条机器指令，程序解析指令并输出对应的微操作序列。
   * 模拟微程序控制器的状态转移过程，逐步执行微指令。

4. **输出要求**：
   * 输出每条机器指令对应的微操作序列。
   * 输出微程序控制器的状态转移过程。

---

### 🔤 输入输出样例：

#### 示例 1（单条指令）：
```
Input Instruction: ADD R1, R2  

Output:  
Micro-operations:  
T1: MAR <- PC  
T2: MDR <- M[MAR]  
T3: IR <- MDR  
T4: A <- R1  
T5: B <- R2  
T6: ALU <- A + B  
T7: R1 <- ALU  
/*
 * State Transitions:  
 * Cycle 1: Fetch (MAR <- PC)  
 * Cycle 2: Fetch (MDR <- M[MAR])  
 * Cycle 3: Decode (IR <- MDR)  
 * Cycle 4: Execute (A <- R1, B <- R2)  
 * Cycle 5: Execute (ALU <- A + B)  
 * Cycle 6: Write Back (R1 <- ALU)
*/
```

#### 示例 2（多条指令）：
```
Input Instructions: LOAD R1, 100  
Output:  
Micro-operations:  
T1: MAR <- PC  
T2: MDR <- M[MAR]  
T3: IR <- MDR  
T4: MAR <- 100  
T5: MDR <- M[MAR]  
T6: R1 <- MDR  

Input Instruction: ADD R1, R2  
Output:
Micro-operations:  
T1: MAR <- PC  
T2: MDR <- M[MAR]  
T3: IR <- MDR  
T4: A <- R1  
T5: B <- R2  
T6: ALU <- A + B  
T7: R1 <- ALU  
```
### 👥 工作分工建议：

* 成员A：指令解析模块；
* 成员B：微操作生成规则；
* 成员C：状态序列输出逻辑。

### 📝 评分标准：

* 微操作设计完整（40%）
* 状态转移模拟准确（30%）
* 输入解析与映射正确（20%）
* 编码规范与注释清晰（10%）

---

## **项目 23：定点乘法器（Booth算法）**

### 🔧 功能要求：

* 实现两个 8 位有符号整数的乘法，采用 Booth 算法。
* 模拟移位寄存器、乘数、被乘数、加法器、控制单元等部件的计算过程。
* 要求逐步显示各轮操作内容（如寄存器值变化），并禁止使用乘法运算符 `*`。

---

### 🔤 输入输出样例：

#### 示例 1（正数乘法）：
```
Input: 3 * 6  

Booth Encoding Step:
Multiplier (6):  00000110  
Multiplicand (3): 00000011  

Step-by-Step Execution:
Cycle 1:  
  Accumulator: 00000000  
  Multiplier:  00000110  
  Q-1:         0  
  Operation:   No operation (Q0 = Q-1)  
  After Shift: Accumulator: 00000000, Multiplier: 00000011, Q-1: 0  

Cycle 2:  
  Accumulator: 00000000  
  Multiplier:  00000011  
  Q-1:         0  
  Operation:   Add Multiplicand (Q0 = 1, Q-1 = 0)  
  After Add:   Accumulator: 00000011  
  After Shift: Accumulator: 00000001, Multiplier: 10000001, Q-1: 1  

... (省略中间步骤)

Final Result: 18
```

#### 示例 2（负数乘法）：
```
Input: -3 * 6  

Booth Encoding Step:
Multiplier (6):  00000110  
Multiplicand (-3): 11111101 (2's complement of 3)  

Step-by-Step Execution:
Cycle 1:  
  Accumulator: 00000000  
  Multiplier:  00000110  
  Q-1:         0  
  Operation:   No operation (Q0 = Q-1)  
  After Shift: Accumulator: 00000000, Multiplier: 00000011, Q-1: 0  

Cycle 2:  
  Accumulator: 00000000  
  Multiplier:  00000011  
  Q-1:         0  
  Operation:   Add Multiplicand (Q0 = 1, Q-1 = 0)  
  After Add:   Accumulator: 11111101  
  After Shift: Accumulator: 11111110, Multiplier: 10000001, Q-1: 1  

... (省略中间步骤)

Final Result: -18
```

### 👥 工作分工建议：

* 成员A：Booth 算法流程实现；
* 成员B：寄存器模拟与位移逻辑；
* 成员C：交互与结果输出模块。

### 📝 评分标准：

* Booth 流程实现正确（40%）
* 禁用乘法符号（20%）
* 每轮状态输出清晰（20%）
* 模块分明、注释完备（20%）

---

## **项目 24：四路组相联缓存模拟器**

### 🔧 功能要求：

* 模拟一个简化的四路组相联缓存（16组，每组4路），使用最近最少使用（LRU）替换策略。
* 支持地址访问、命中/未命中反馈，并显示缓存结构状态。
* 使用 C 结构体管理缓存，禁止使用 STL（如 C++ 的 `vector` 等）或任何动态内存分配。

---

### 🔤 输入输出样例：

#### 示例 1（命中）：
```
Access Address: 0x2A4  
Binary Address: 001010100100  
Set Index: 10  
Tag: 0x2  
Result: Hit  
Cache Set 10: [0x2A4, 0x1B8, 0x3C0, 0x4D2] (LRU updated)
```

#### 示例 2（未命中，替换）：
```
Access Address: 0x5E0  
Binary Address: 010111100000  
Set Index: 14  
Tag: 0x5  
Result: Miss  
Cache Set 14 (Before): [0x1E4, 0x2F8, 0x3A0, 0x4B2]  
Replaced: 0x1E4 (Least Recently Used)  
Cache Set 14 (After): [0x5E0, 0x2F8, 0x3A0, 0x4B2] (LRU updated)
```

#### 示例 3（初始状态）：
```
Access Address: 0x1B8  
Binary Address: 000110111000  
Set Index: 6  
Tag: 0x1  
Result: Miss  
Cache Set 6 (Before): [Empty, Empty, Empty, Empty]  
Cache Set 6 (After): [0x1B8, Empty, Empty, Empty] (LRU updated)
```

### 👥 工作分工建议：

* 成员A：缓存结构定义与初始化；
* 成员B：替换策略与LRU实现；
* 成员C：交互与输出显示。

### 📝 评分标准：

* 命中/替换逻辑准确（40%）
* LRU实现完整（30%）
* 输出状态清晰（15%）
* 模块划分清楚，注释规范（15%）

---

## **项目 25：寄存器组模拟器**

### 🔧 功能要求：

* 模拟一个包含 **32个通用寄存器** 的寄存器堆，支持三操作数格式的读写（2读1写）。
* 检测并处理读写冲突（如同一条指令中对同一寄存器既读又写）。
* 输入一系列伪汇编格式语句，更新寄存器状态并输出变化。
* 所有寄存器初始值为 0，用户可通过 `LOAD` 或 `MOV` 指令为寄存器赋初值。
* 支持以下伪汇编指令格式：
  - `LOAD R1, #value`：将立即数 `value` 加载到寄存器 `R1`。
  - `ADD R1, R2, R3`：R1 = R2 + R3
  - `SUB R4, R5, R6`：R4 = R5 - R6
  - `MUL R7, R8, R9`：R7 = R8 * R9
  - `DIV R10, R11, R12`：R10 = R11 / R12
* 使用字符串解析输入，提取操作码、寄存器编号和立即数。
---

### 🔤 输入输出样例：

#### 示例 1（初始化寄存器值）：
```
Instruction: LOAD R2, #2  
Operation: R2 = 2  
Register File: [R0=0, R1=0, R2=2, R3=0, ..., R31=0]
```

#### 示例 2（基本操作）：
```
Instruction: ADD R1, R2, R3  
Operation: R1 = R2 + R3  
Register File: [R0=0, R1=5, R2=2, R3=3, ..., R31=0]
```

#### 示例 3（冲突检测）：
```
Instruction: ADD R1, R1, R2  
Conflict Detected: R1 is both read and written in the same instruction.  
Operation: R1 = Old R1 + R2  
Register File: [R0=0, R1=7, R2=3, ..., R31=0]
```

#### 示例 4（多条指令）：
```
Input Instructions:  
1. LOAD R2, #2  
2. LOAD R3, #3  
3. ADD R1, R2, R3  
4. SUB R4, R1, R2  

Output:  
Instruction 1: LOAD R2, #2  
Operation: R2 = 2  
Register File: [R0=0, R1=0, R2=2, R3=0, ..., R31=0]

Instruction 2: LOAD R3, #3  
Operation: R3 = 3  
Register File: [R0=0, R1=0, R2=2, R3=3, ..., R31=0]

Instruction 3: ADD R1, R2, R3  
Operation: R1 = R2 + R3  
Register File: [R0=0, R1=5, R2=2, R3=3, ..., R31=0]

Instruction 4: SUB R4, R1, R2  
Operation: R4 = R1 - R2  
Register File: [R0=0, R1=5, R2=2, R3=3, R4=3, ..., R31=0]
```

#### 示例 5（非法指令）：
```
Instruction: ADD R32, R1, R2  
Error: Invalid register R32. Register index must be between R0 and R31.
```

### 👥 工作分工建议：

* 成员A：输入解析；
* 成员B：寄存器结构与更新；
* 成员C：冲突检测与结果显示。

### 📝 评分标准：

* 输入解析正确（30%）
* 冲突检测与处理准确（30%）
* 寄存器显示清晰（20%）
* 模块化与注释（20%）

---

## **项目 26：算术逻辑单元（ALU）模拟器**

### 🔧 功能要求：

* 实现一个支持以下运算的 ALU 模块：
  - 加法（ADD）
  - 减法（SUB）
  - 按位与（AND）
  - 按位或（OR）
  - 按位异或（XOR）
  - 按位非（NOT，仅对操作数 A）
  - 左移（SHL）
  - 右移（SHR）
* ALU 接收一条 20 位机器码作为输入，解析操作数和操作码，输出结果及标志位：
  - **Zero Flag (ZF)**：结果是否为零。
  - **Carry Flag (CF)**：是否产生进位（仅对加法和减法有效）。
* 禁止使用 C 语言的位运算符（如 `~`, `^`, `&` 等），需手动实现位操作逻辑。

---

### 🔤 输入格式：

1. **机器码格式**：
   * 输入一条 20 位二进制字符串，格式如下：
     ```
     [4 位操作码][8 位操作数 A][8 位操作数 B]
     ```
   * 如果操作仅需要一个操作数（如 NOT），操作数 B 的部分填充为 `00000000`。

2. **操作码定义**：
   * 使用以下 4 位操作码指定运算类型：
     - `0000`：ADD（加法）
     - `0001`：SUB（减法）
     - `0010`：AND（按位与）
     - `0011`：OR（按位或）
     - `0100`：XOR（按位异或）
     - `0101`：NOT（按位非，仅对 A）
     - `0110`：SHL（左移）
     - `0111`：SHR（右移）

---

### 🔤 输入输出样例：

#### 示例 1（加法）：
```
Input: 0000000011000101  // ADD, A=12, B=5
Output:
  Result: 17
  Zero Flag: 0
  Carry Flag: 0
```

#### 示例 2（按位与）：
```
Input: 0010000011000101  // AND, A=12, B=5
Output:
  Result: 4
  Zero Flag: 0
  Carry Flag: 0
```

#### 示例 3（按位非）：
```
Input: 0101000011000000  // NOT, A=12
Output:
  Result: 243
  Zero Flag: 0
  Carry Flag: N/A
```

#### 示例 4（左移）：
```
Input: 0110000011000000  // SHL, A=12
Output:
  Result: 24
  Zero Flag: 0
  Carry Flag: 0
```

### 👥 工作分工建议：

* 成员A：ALU操作码解析；
* 成员B：ALU功能模块实现（禁止直接使用运算符）；
* 成员C：标志寄存器状态计算。

### 📝 评分标准：

* ALU 操作实现完整（40%）
* 禁用原始运算符符号成功（20%）
* 标志位计算准确（20%）
* 模块化与说明文档（20%）

---

## **项目 27：简化版 MIPS 解释器**

### 🔧 功能要求：

* 实现一个简化版 MIPS 汇编指令解释器，支持基本的R型和I型指令：

  * `ADD`, `SUB`, `AND`, `OR`, `SLT`
  * `LW`, `SW`, `BEQ`, `BNE`
* 程序接收一组汇编指令文本作为输入，模拟寄存器堆和内存的行为并按顺序执行。
* 内存使用固定大小数组模拟；程序中禁止使用 `eval` 等动态解释技术。

### 🔤 输入输出样例：

```
Input:
    ADD R1, R2, R3
    SUB R4, R1, R2
    SW R4, 0(R5)
    LW R6, 0(R5)
    BEQ R6, R4, LABEL

Output:
    R1 = R2 + R3 = 10
    R4 = R1 - R2 = 5
    MEM[Addr in R5] = R4 = 5
    R6 loaded from memory = 5
    Branch to LABEL: YES
```

### 👥 工作分工建议：

* 成员A：汇编解析器实现；
* 成员B：寄存器/内存结构与模拟；
* 成员C：跳转与分支逻辑实现。

### 📝 评分标准：

* 指令解析与执行正确（40%）
* 跳转/分支逻辑正确（25%）
* 数据存取与更新准确（20%）
* 程序结构、可扩展性、注释良好（15%）

---

## **项目 28：五级流水线执行器模拟（带冒泡插入）**

### 🔧 功能要求：

* 实现一个可模拟五级流水线（IF, ID, EX, MEM, WB）指令执行器。
* 输入为一个简化汇编程序，输出为每条指令在每周期的位置（流水线状态表），自动检测并插入 NOP 解决数据冲突（RAW）和结构冲突。
* 指令格式与 MIPS 类似。
* 需显示完整的执行过程，时间表格式如 Gantt 图样式。

### 🔤 输入输出样例：

```
Instruction List:
    LOAD R1, 0(R2)
    ADD R3, R1, R4
    SUB R5, R3, R6

Pipeline:
Cycle 1: IF
Cycle 2: ID   IF
Cycle 3: EX   NOP   IF
Cycle 4: MEM  ID    NOP
Cycle 5: WB   EX    ID
...
```

### 👥 工作分工建议：

* 成员A：数据结构设计与流水线建模；
* 成员B：冒泡插入逻辑实现；
* 成员C：输出格式（表格/Gantt图风格）生成。

### 📝 评分标准：

* 流水线周期状态模拟正确（40%）
* 冲突检测与冒泡插入准确（30%）
* 输出表格清晰、规范（15%）
* 程序注释与设计合理（15%）

---

## **项目 29：两级缓存一致性模拟器（MESI 协议）**

### 🔧 功能要求：

* 模拟两个CPU核，每个拥有自己的一级缓存L1。
* 实现 MESI（一致性）协议以确保写操作的缓存一致性。
* 模拟跨核心访问/修改共享变量的场景，展示状态转移过程。
* 禁止使用共享全局变量直接同步，必须使用协议状态机控制。

### 🔤 输入输出样例：

```
Core 0: LOAD X
Core 1: STORE X

State Transitions:
Core 0: X in Shared
Core 1: X in Modified
Core 0: X invalidated
```

### 👥 工作分工建议：

* 成员A：缓存数据结构与状态机建模；
* 成员B：MESI协议状态转换逻辑实现；
* 成员C：交互与访问模拟输出。

### 📝 评分标准：

* MESI协议状态机实现准确（40%）
* 缓存状态更新逻辑正确（30%）
* 多核访问交互设计合理（20%）
* 程序结构清晰、注释齐全（10%）

---

## **项目 30：微型指令集架构设计与解释器实现**

### 🔧 功能要求：

* 自定义一个 8 位微型指令集（例如指令长度为 8-bit，支持基本算术与逻辑运算、跳转、内存访问）。
* 设计其编码格式、寄存器与内存结构。
* 实现一个解释器可以解析、加载并运行该指令集程序，并输出执行日志。
* 要求不得使用已有汇编解释器或虚拟机库，指令解析必须自己手动实现。

### 🔤 输入输出样例：

```
Instruction Set Format:  
  Opcode: 3 bits  
  Operand1: 2 bits  
  Operand2: 3 bits  

Input Program (in binary):  
  00001011  // ADD R0, R3  
  00111000  // MOV R1, #0  

Execution Log:
  R0 = R0 + R3 = 7  
  R1 = 0
```

### 👥 工作分工建议：

* 成员A：指令集设计与编码；
* 成员B：解释器与执行引擎实现；
* 成员C：执行日志格式与程序加载。

### 📝 评分标准：

* 指令集设计合理，结构清晰（30%）
* 解释器执行正确无误（40%）
* 日志输出规范、逻辑清楚（15%）
* 编码规范与注释完备（15%）