编程与数学 03-001 计算机组成原理 20_计算机组成原理实践（实验）

摘要：本文介绍了计算机组成原理的实践学习，重点记录了使用Logisim设计简单CPU以及使用Verilog实现ALU和流水线模块的实验过程。通过Logisim，设计了一个8位简易CPU，包含完整的指令集和数据通路。使用Verilog实现了功能完备的ALU模块，支持多种算术逻辑运算，并构建了五级流水线CPU的基本框架。实验中遇到了时序问题、仿真错误和流水线冲突等挑战，通过合理设置时钟周期、检查寄存器初始化和实现转发机制等方法解决了这些问题。通过实践，加深了对计算机组成原理的理解，为后续学习打下了坚实基础。

关键词：计算机组成原理、Logisim、Verilog、CPU设计、ALU、流水线、实践

人工智能助手：DeepSeek

---

1. 引言：实践在计算机组成原理学习中的重要性

计算机组成原理作为计算机科学与技术专业的核心课程，不仅需要扎实的理论基础，更需要通过实践来深化对计算机硬件系统的理解。本学习笔记将重点记录使用Logisim设计简单CPU以及使用Verilog实现ALU和流水线模块的实验过程与心得体会。

通过硬件描述语言和电路仿真工具的实践操作，能够将抽象的计算机组成概念具体化，真正理解数据在计算机中的流动过程、指令的执行机制以及各硬件组件的协同工作方式。这种"做中学"的方式对于培养硬件设计思维和解决实际工程问题的能力至关重要。

2. Logisim基础与简单CPU设计

2.1 Logisim工具简介

Logisim是一款开源的数字电路仿真与设计工具，具有以下特点：

• 图形化界面：通过拖放组件构建电路
• 分层设计：支持子电路和模块复用
• 内置组件库：包含基本逻辑门、存储器、输入输出设备等
• 仿真功能：可逐步执行或连续运行电路
• 跨平台：基于Java开发，支持多操作系统

2.1.1 Logisim基本操作

1. 创建新项目与电路
2. 添加组件（工具栏选择）
3. 连接线路（使用布线工具）
4. 设置组件属性（双击组件）
5. 测试电路（使用poke工具或时钟控制）

2.2 简单CPU设计规划

2.2.1 CPU基本结构

设计一个8位简易CPU，包含以下组件：

• 寄存器文件（4个8位通用寄存器）
• 算术逻辑单元（ALU）
• 控制单元
• 程序计数器（PC）
• 指令存储器（ROM）
• 数据存储器（RAM）
• 总线系统

2.2.2 指令集设计

设计精简指令集（RISC风格），包含以下指令类型：

指令类型	操作码	功能说明
ADD	0000	Rd ← Rs + Rt
SUB	0001	Rd ← Rs - Rt
AND	0010	Rd ← Rs & Rt
OR	0011	Rd ← Rs
LOAD	0100	Rd ← M[imm]
STORE	0101	M[imm] ← Rs
JMP	0110	PC ← imm
BNE	0111	if Rs≠Rt then PC←PC+imm

指令格式：

• R型指令：opcode(4) | rd(2) | rs(2) | rt(2)
• I型指令：opcode(4) | rd(2) | imm(6)

2.3 各模块设计与实现

2.3.1 寄存器文件设计

• 4个8位寄存器（R0-R3）
• 双端口读取，单端口写入
• 寄存器选择通过2位地址线
• 写使能控制信号

Logisim实现步骤：

1. 创建"Register File"子电路
2. 添加4个8位寄存器组件
3. 使用多路选择器实现读端口选择
4. 添加解码器控制写端口
5. 连接时钟和使能信号

2.3.2 ALU设计

支持以下操作：

• 加法（ADD）
• 减法（SUB）
• 按位与（AND）
• 按位或（OR）

功能表：

ALUop(2)	功能
00	ADD
01	SUB
10	AND
11	OR

Logisim实现：

1. 创建"ALU"子电路
2. 添加加法器、减法器、逻辑门
3. 使用多路选择器选择运算结果
4. 添加零标志位检测电路

2.3.3 控制单元设计

根据指令操作码生成控制信号：

• RegWrite：寄存器写使能
• ALUop：ALU操作选择
• MemRead：存储器读
• MemWrite：存储器写
• Branch：分支指令
• Jump：跳转指令

Logisim实现：

1. 创建"Control Unit"子电路
2. 使用解码器解析操作码
3. 组合逻辑生成控制信号

2.3.4 数据通路整合

将各模块连接成完整数据通路：

1. 添加指令存储器（ROM）
2. 连接程序计数器（PC）
3. 整合寄存器文件和ALU
4. 添加数据存储器（RAM）
5. 实现分支和跳转逻辑

2.4 测试与调试

2.4.1 测试程序编写

编写简单汇编程序测试CPU功能：

LOAD R0, 5     // R0 = 5
LOAD R1, 3     // R1 = 3
ADD R2, R0, R1 // R2 = R0 + R1 = 8
STORE R2, 0x10 // M[16] = 8
BNE R0, R1, 2  // 跳转2条指令
SUB R3, R0, R1 // 不会执行
AND R3, R0, R1 // R3 = R0 & R1 = 1

转换为机器码并存入ROM。

2.4.2 调试技巧

1. 使用Logisim的"模拟启用"逐步执行
2. 添加探针监视关键信号
3. 使用时钟单步模式
4. 检查数据通路各阶段的值

2.4.3 常见问题与解决

1. 信号冲突：确保同一时刻只有一个组件驱动总线
2. 时序问题：合理安排时钟边沿和信号稳定时间
3. 指令解码错误：检查控制单元真值表
4. 存储器初始化失败：确认ROM已正确加载程序

3. Verilog实现ALU模块

3.1 Verilog语言基础

3.1.1 Verilog设计层次

1. 行为级描述：算法级抽象
2. 数据流描述：寄存器传输级（RTL）
3. 门级描述：逻辑门和触发器互连

3.1.2 基本语法结构

• 模块定义：module和endmodule
• 端口声明：input, output, inout
• 数据类型：wire, reg
• 赋值语句：连续赋值assign，过程赋值=,<=
• 行为描述：always块

3.1.3 测试平台编写

使用initial块生成测试激励：

initial begin
    // 初始化输入
    a = 0; b = 0; op = 0;
    
    // 测试用例
    #10 a = 8'h05; b = 8'h03; op = 2'b00; // ADD
    #10 op = 2'b01; // SUB
    #10 op = 2'b10; // AND
    #10 op = 2'b11; // OR
    
    #10 $finish;
end

3.2 ALU模块设计

3.2.1 模块接口定义

module ALU (
    input [7:0] a,      // 操作数A
    input [7:0] b,      // 操作数B
    input [1:0] op,     // 操作码
    output reg [7:0] out, // 运算结果
    output zero         // 零标志
);

3.2.2 功能实现

always @(*) begin
    case(op)
        2'b00: out = a + b;   // ADD
        2'b01: out = a - b;   // SUB
        2'b10: out = a & b;   // AND
        2'b11: out = a | b;   // OR
        default: out = 8'b0;
    endcase
end

assign zero = (out == 8'b0);  // 零标志

3.2.3 完整实现代码

`timescale 1ns / 1ps

module ALU(
    input [7:0] a,
    input [7:0] b,
    input [1:0] op,
    output reg [7:0] out,
    output zero
);
    
    always @(*) begin
        case(op)
            2'b00: out = a + b;   // ADD
            2'b01: out = a - b;   // SUB
            2'b10: out = a & b;   // AND
            2'b11: out = a | b;   // OR
            default: out = 8'b0;
        endcase
    end
    
    assign zero = (out == 8'b0);
    
endmodule

module ALU_tb;
    reg [7:0] a, b;
    reg [1:0] op;
    wire [7:0] out;
    wire zero;
    
    ALU uut (.a(a), .b(b), .op(op), .out(out), .zero(zero));
    
    initial begin
        $monitor("At time %t, a=%h b=%h op=%b => out=%h zero=%b", 
                $time, a, b, op, out, zero);
        
        a = 8'h05; b = 8'h03; op = 2'b00; #10; // ADD: 5+3=8
        op = 2'b01; #10; // SUB: 5-3=2
        op = 2'b10; #10; // AND: 5&3=1
        op = 2'b11; #10; // OR: 5|3=7
        
        $finish;
    end
endmodule

3.3 仿真与验证

3.3.1 使用ModelSim仿真

1. 创建工程并添加源文件
2. 编译设计文件和测试平台
3. 启动仿真
4. 添加波形观察信号
5. 运行并分析结果

3.3.2 预期波形

时间	a	b	op	out	zero
10	5	3	00	08	0
20	5	3	01	02	0
30	5	3	10	01	0
40	5	3	11	07	0

3.3.3 功能覆盖测试

设计测试用例覆盖：

• 所有运算类型
• 边界值（最大/最小值）
• 零标志触发条件
• 溢出情况（可选）

4. Verilog实现流水线CPU模块

4.1 流水线基本概念

4.1.1 五级流水线阶段

1. 取指（IF）：从指令存储器读取指令
2. 译码（ID）：解析指令，读取寄存器
3. 执行（EX）：ALU运算
4. 访存（MEM）：数据存储器访问
5. 回写（WB）：结果写回寄存器

4.1.2 流水线寄存器

相邻阶段间插入寄存器，保存中间结果和控制信号：

• IF/ID寄存器
• ID/EX寄存器
• EX/MEM寄存器
• MEM/WB寄存器

4.2 流水线模块实现

4.2.1 取指阶段（IF）

module IF_stage(
    input clk,
    input reset,
    input PCSrc,
    input [7:0] BranchTarget,
    output [7:0] PC,
    output [11:0] Instruction
);
    reg [7:0] PC_reg;
    wire [7:0] PC_next;
    
    // 指令存储器（模拟）
    reg [11:0] IMEM [0:255];
    
    initial begin
        $readmemb("program.bin", IMEM);
    end
    
    // PC更新逻辑
    assign PC_next = PCSrc ? BranchTarget : (PC_reg + 1);
    
    always @(posedge clk or posedge reset) begin
        if (reset) PC_reg <= 8'b0;
        else PC_reg <= PC_next;
    end
    
    assign PC = PC_reg;
    assign Instruction = IMEM[PC_reg];
endmodule

4.2.2 译码阶段（ID）

module ID_stage(
    input clk,
    input [11:0] Instruction,
    input RegWrite,
    input [7:0] WriteData,
    input [1:0] WriteReg,
    output [7:0] ReadData1,
    output [7:0] ReadData2,
    output [1:0] Rd,
    output [7:0] Imm,
    output [1:0] ALUop
);
    // 寄存器文件
    reg [7:0] RegFile [0:3];
    
    // 指令解码
    wire [3:0] opcode = Instruction[11:8];
    assign Rd = Instruction[7:6];
    wire [1:0] Rs = Instruction[5:4];
    wire [1:0] Rt = Instruction[3:2];
    assign Imm = {2'b0, Instruction[5:0]};
    
    // 控制信号生成
    assign ALUop = (opcode[3:2] == 2'b00) ? 2'b00 : // ADD
                  (opcode[3:2] == 2'b01) ? 2'b01 : // SUB
                  (opcode[3:2] == 2'b10) ? 2'b10 : // AND
                                           2'b11;  // OR
    
    // 寄存器读
    assign ReadData1 = RegFile[Rs];
    assign ReadData2 = RegFile[Rt];
    
    // 寄存器写
    always @(posedge clk) begin
        if (RegWrite) RegFile[WriteReg] <= WriteData;
    end
endmodule

4.2.3 流水线寄存器实现

module IF_ID_Reg(
    input clk,
    input [7:0] PC_in,
    input [11:0] Instruction_in,
    output reg [7:0] PC_out,
    output reg [11:0] Instruction_out
);
    always @(posedge clk) begin
        PC_out <= PC_in;
        Instruction_out <= Instruction_in;
    end
endmodule

4.3 流水线冲突处理

4.3.1 数据冲突与转发

// 在EX阶段添加转发逻辑
wire [7:0] ALU_input1 = (ForwardA == 2'b01) ? EX_MEM_ALUResult :
                        (ForwardA == 2'b10) ? MEM_WB_WriteData :
                        ID_EX_ReadData1;

wire [7:0] ALU_input2 = (ForwardB == 2'b01) ? EX_MEM_ALUResult :
                        (ForwardB == 2'b10) ? MEM_WB_WriteData :
                        ID_EX_ReadData2;

4.3.2 控制冲突与分支预测

// 简单分支处理
assign PCSrc = (ID_Branch & (ID_ReadData1 != ID_ReadData2));
assign BranchTarget = ID_PC + ID_Imm;

4.4 完整流水线集成

4.4.1 顶层模块

module Pipeline_CPU(
    input clk,
    input reset
);
    // 阶段间寄存器
    wire [7:0] IF_PC, ID_PC;
    wire [11:0] IF_Instruction, ID_Instruction;
    
    // 各阶段控制信号
    wire ID_RegWrite, EX_RegWrite, MEM_RegWrite, WB_RegWrite;
    wire [1:0] EX_ALUop;
    wire EX_Branch;
    
    // 数据通路信号
    wire [7:0] ALUResult, MEM_ReadData, WB_WriteData;
    wire [1:0] WB_WriteReg;
    
    // 各阶段实例化
    IF_stage IF(.clk(clk), .reset(reset), .PCSrc(PCSrc), 
                .BranchTarget(BranchTarget), .PC(IF_PC), 
                .Instruction(IF_Instruction));
    
    IF_ID_Reg IF_ID(.clk(clk), .PC_in(IF_PC), 
                   .Instruction_in(IF_Instruction),
                   .PC_out(ID_PC), .Instruction_out(ID_Instruction));
    
    ID_stage ID(.clk(clk), .Instruction(ID_Instruction),
               .RegWrite(WB_RegWrite), .WriteData(WB_WriteData),
               .WriteReg(WB_WriteReg), /* 其他输出 */);
    
    // 其他阶段类似...
endmodule

4.4.2 测试激励

module Pipeline_CPU_tb;
    reg clk, reset;
    
    Pipeline_CPU cpu(.clk(clk), .reset(reset));
    
    initial begin
        clk = 0;
        reset = 1;
        #10 reset = 0;
        
        // 运行足够时钟周期
        #200 $finish;
    end
    
    always #5 clk = ~clk;
endmodule

5. 实验总结与思考

5.1 实验成果总结

通过本次实验，我实现了：

1. 使用Logisim设计了8位简易CPU，包含完整的指令集和数据通路
2. 使用Verilog实现了功能完备的ALU模块，支持多种算术逻辑运算
3. 构建了五级流水线CPU的基本框架，包括各阶段模块和流水线寄存器
4. 学习了处理数据冲突的转发技术和控制冲突的简单分支处理

5.2 遇到的挑战与解决方案

1. Logisim时序问题：

   • 现象：寄存器更新不及时
   • 解决：合理设置时钟周期，确保信号稳定

2. Verilog仿真错误：

   • 现象：ALU输出为不定态
   • 解决：检查未初始化的寄存器，添加复位逻辑

3. 流水线冲突：

   • 现象：后续指令使用错误数据
   • 解决：实现转发机制，插入气泡（stall）

5.3 进一步改进方向

1. 扩展指令集：

   • 增加乘法、移位等指令
   • 支持立即数操作

2. 增强流水线：

   • 实现精确异常处理
   • 添加分支预测缓冲

3. 性能优化：

   • 采用超流水线设计
   • 实现指令缓存和数据缓存

4. 验证完善：

   • 构建更全面的测试平台
   • 增加覆盖率分析

5.4 实践心得

计算机组成原理实验让我深刻理解了：

1. 硬件设计的严谨性：每个信号、每个时序都必须精确控制
2. 抽象与实现的差距：理论上的设计到实际电路需要考虑更多细节
3. 调试的重要性：系统化的调试方法能显著提高效率
4. 模块化设计的好处：清晰的接口定义便于团队协作和问题定位

这些实践经验不仅加深了对计算机组成原理的理解，也为后续学习计算机体系结构、操作系统等课程打下了坚实基础。