多周期CPU的设计与实现
- 本次实验是在单周期CPU的基础上完成了，将每条指令只需要一个周期，切割成sIF、sID、sEXE、sMEM、sWB五个周期
- 单周期CPU的内容详见我的另外一篇CSDN博客：单周期CPU
- 多周期CPU的整个项目下载链接：多周期CPU
实验内容
设计一个多周期CPU，该CPU至少能实现以下指令功能操作。需设计的指令与格式如下：（说明：操作码按照以下规定使用，都给每类指令预留扩展空间，后续实验相同。）
实验原理
多周期CPU指的是将整个CPU的执行过程分成几个阶段，每个阶段用一个时钟去完成，然后开始下一条指令的执行，而每种指令执行时所用的时钟数不尽相同，这就是所谓的多周期CPU。CPU在处理指令时，一般需要经过以下几个阶段：
(1) 取指令(IF)：根据程序计数器pc中的指令地址，从存储器中取出一条指令，同时，pc根据指令字长度自动递增产生下一条指令所需要的指令地址，但遇到“地址转移”指令时，则控制器把“转移地址”送入pc，当然得到的“地址”需要做些变换才送入pc。
(2) 指令译码(ID)：对取指令操作中得到的指令进行分析并译码，确定这条指令需要完成的操作，从而产生相应的操作控制信号，用于驱动执行状态中的各种操作。
(3) 指令执行(EXE)：根据指令译码得到的操作控制信号，具体地执行指令动作，然后转移到结果写回状态。
(4) 存储器访问(MEM)：所有需要访问存储器的操作都将在这个步骤中执行，该步骤给出存储器的数据地址，把数据写入到存储器中数据地址所指定的存储单元或者从存储器中得到数据地址单元中的数据。
(5) 结果写回(WB)：指令执行的结果或者访问存储器中得到的数据写回相应的目的寄存器中。
实验中就按照这五个阶段进行设计，这样一条指令的执行最长需要五个(小)时钟周期才能完成，但具体情况怎样？要根据该条指令的情况而定，有些指令不需要五个时钟周期的，这就是多周期的CPU。
其中，
op：为操作码；
rs：为第1个源操作数寄存器，寄存器地址（编号）是00000~11111，00~1F；
rt：为第2个源操作数寄存器，或目的操作数寄存器，寄存器地址（同上）；
rd：为目的操作数寄存器，寄存器地址（同上）；
sa：为位移量（shift amt），移位指令用于指定移多少位；
funct：为功能码，在寄存器类型指令中（R类型）用来指定指令的功能；
immediate：为16位立即数，用作无符号的逻辑操作数、有符号的算术操作数、数据加载（Load）/数据保存（Store）指令的数据地址字节偏移量和分支指令中相对程序计数器（PC）的有符号偏移量；
address：为地址。
状态的转移有的是无条件的，例如从sIF状态转移到sID就是无条件的；有些是有条件的，例如sEXE状态之后不止一个状态，到底转向哪个状态由该指令功能，即指令操作码决定。每个状态代表一个时钟周期。
图3是多周期CPU控制部件的电路结构，三个D触发器用于保存当前状态，是时序逻辑电路，RST用于初始化状态“000“，另外两个部分都是组合逻辑电路，一个用于产生下一个阶段的状态，另一个用于产生每个阶段的控制信号。从图上可看出，下个状态取决于指令操作码和当前状态；而每个阶段的控制信号取决于指令操作码、当前状态和反映运算结果的状态zero标志和符号sign标志。
图4是一个简单的基本上能够在多周期CPU上完成所要求设计的指令功能的数据通路和必要的控制线路图。其中指令和数据各存储在不同存储器中，即有指令存储器和数据存储器。访问存储器时，先给出内存地址，然后由读或写信号控制操作。对于寄存器组，给出寄存器地址（编号），读操作时不需要时钟信号，输出端就直接输出相应数据；而在写操作时，在 WE使能信号为1时，在时钟边沿触发将数据写入寄存器。图中控制信号功能如表1所示，表2是ALU运算功能表。
特别提示，图上增加IR指令寄存器，目的是使指令代码保持稳定，pc写使能控制信号PCWre，是确保pc适时修改，原因都是和多周期工作的CPU有关。ADR、BDR、ALUoutDR、DBDR四个寄存器不需要写使能信号，其作用是切分数据通路，将大组合逻辑切分为若干个小组合逻辑，大延迟变为多个分段小延迟。
表1 控制信号作用
| 控制信号名 | 状态“0” | 状态“1” |
|---|---|---|
| RST | 对于PC，初始化PC为程序首地址 | 对于PC，PC接收下一条指令地址 |
| PCWre | PC不更改，相关指令：halt，另外，除‘000’状态之外，其余状态慎改PC的值。 | PC更改，相关指令：除指令halt外，另外，在‘000’状态时，修改PC的值合适。 |
| ALUSrcA | 来自寄存器堆data1输出，相关指令：add、sub、addi、or、and、ori、beq、bltz、slt、sltiu、sw、lw | 来自移位数sa，同时，进行(zero-extend)sa，即 {{27{1’b0}},sa}，相关指令：sll |
| ALUSrcB | 来自寄存器堆data2输出，相关指令：add、sub、or、and、beq、bltz、slt、sll | 来自sign或zero扩展的立即数，相关指令：addi、ori、sltiu、lw、sw |
| DBDataSrc | 来自ALU运算结果的输出，相关指令：add、sub、addi、or、and、ori、slt、sltiu、sll | 来自数据存储器（Data MEM）的输出，相关指令：lw |
| RegWre | 无写寄存器组寄存器，相关指令：beq、bltz、j、sw、jr、halt | 寄存器组寄存器写使能，相关指令：add、sub、addi、or、and、ori、slt、sltiu、sll、lw、jal |
| WrRegDSrc | 写入寄存器组寄存器的数据来自pc+4(pc4），相关指令：jal，写$31 | 写入寄存器组寄存器的数据来自ALU运算结果或存储器读出的数据，相关指令：add、addi、sub、or、and、ori、slt、sltiu、sll、lw |
| InsMemRW | 写指令存储器 | 读指令存储器(Ins. Data) |
| mRD | 存储器输出高阻态 | 读数据存储器，相关指令：lw |
| mWR | 无操作 | 写数据存储器，相关指令：sw |
| IRWre | IR(指令寄存器)不更改 | IR寄存器写使能。向指令存储器发出读指令代码后，这个信号也接着发出，在时钟上升沿，IR接收从指令存储器送来的指令代码。与每条指令都相关。 |
| ExtSel | (zero-extend)immediate，相关指令：ori、sltiu； | (sign-extend)immediate，相关指令：addi、lw、sw、beq、bltz； |
| PCSrc[1:0] | 00：pc<－pc+4，相关指令：add、addi、sub、or、ori、and、slt、sltiu、sll、sw、lw、beq(zero=0)、bltz(sign=0，或zero=1)；01：pc<－pc+4+(sign-extend)immediate，相关指令：beq(zero=1)、bltz(sign=1，zero=0)； | 10：pc<－rs，相关指令：jr； 11：pc<－{(pc+4)[31:28],addr[27:2],2’b00}，相关指令：j、jal； |
| RegDst[1:0] | 写寄存器组寄存器的地址，来自：00：0x1F( 31<-pc+4）；01：rt字段，相关指令：addi、ori、sltiu、lw； | 10：rd字段，相关指令：add、sub、or、and、slt、sll；11：未用； |
| ALUOp[2:0] | ALU 8种运算功能选择(000-111)，看功能表 |
相关部件及引脚说明：
- Instruction Memory：指令存储器
- Iaddr，指令地址输入端口
- DataIn，存储器数据输入端口
- DataOut，存储器数据输出端口
- RW，指令存储器读写控制信号，为0写，为1读
- Data Memory：数据存储器
- Daddr，数据地址输入端口
- DataIn，存储器数据输入端口
- DataOut，存储器数据输出端口
- /RD，数据存储器读控制信号，为0读
- /WR，数据存储器写控制信号，为0写
- Register File：寄存器组
- Read Reg1，rs寄存器地址输入端口
- Read Reg2，rt寄存器地址输入端口
- Write Reg，将数据写入的寄存器，其地址输入端口（rt、rd）
- Write Data，写入寄存器的数据输入端口
- Read Data1，rs寄存器数据输出端口
- Read Data2，rt寄存器数据输出端口
- WE，写使能信号，为1时，在时钟边沿触发写入
- IR： 指令寄存器，用于存放正在执行的指令代码
- ALU： 算术逻辑单元
- result，ALU运算结果
- zero，运算结果标志，结果为0，则zero=1；否则zero=0
- sign，运算结果标志，结果最高位为0，则sign=0，正数；否则，sign=1，负数
表2 ALU运算功能表
| ALUOp[2..0] | 功能 | 描述 |
|---|---|---|
| 000 | Y = A + B | 加 |
| 001 | Y = A – B | 减 |
| 010 | Y=（A |
实验器材
PC机一台，BASYS 3 实验板一块，Xilinx Vivado 开发软件一套。
各模块的代码
1． CPU的设计，主要是依照实验原理中的数据通路图以及控制信号的表格进行坟墓快设计的。其中分为十二个底层模块以及一个顶层模块，具体的模块内容及作用如下：
顶层模块（1个）：
（1） Main
作用：负责统筹11个模块的输入输出参数，通过设置多个wire类型的变量，及时拿到各个模块的输出，并传入到需要改输入参数的模块中去。
关键代码：
1. module Main(
2. input CLK, //时钟
3. input Reset, //重置信号
4. output zero,pcWre, //ALU结果是否为0， PC更改信号
5. output[1:0] pcSrc, //PC四选一选择器的控制信号
6. output[2:0] aluop, //ALU的执行信号
7. output[5:0] op, //指令操作的代码
8. output[31:0] readData1, readData2, extendData, writeData, o_p, currentAdd, Result //寄存器1读取的值，寄存器2读取的值，拓展符号信号，写入寄存器的数据， 32位的整条指令， 当前指令的地址， ALU输出的结果
9. ); 底层模块（10个）：
（1） PC
作用：根据传入的PCWre控制信号，进行地址移位操作。当PCWre为0时，指令地址保持不变；当PCWre为1时，指令地址变更为新地址。与单周期CPU相同。
代码：
1. module PC(
2. input CLK,
3. input Reset,
4. input PCWre,//值为0时不更改，代表停机指令；值为1的时候进行更改
5. input [31:0] NewAdd,
6. output reg[31:0] CurrentAdd
7. );
8.
9. initial begin
10. CurrentAdd <= 0;
11. end
12.
13. always@(posedge CLK or negedge Reset)
14. begin
15. if(Reset == 0) CurrentAdd <= 0;
16. else
17. begin
18. if(PCWre == 0) CurrentAdd <= CurrentAdd;
19. else CurrentAdd <= NewAdd;
20. end
21. end
22. endmodule （2） ROM（指令存储器）
作用：通过从文件中读取相关的指令，并按照实验要求存储在8位的寄存器中，并根据传入的地址，输出对应地址的指令。与单周期CPU相同。
代码：
1. module ROM ( rd, addr, dataOut); // 存储器模块
2. input rd; // 读使能信号
3. input [ 31:0] addr; // 存储器地址
4. output reg [31:0] dataOut; // 输出的数据
5.
6. reg [7:0] rom [99:0]; // 存储器定义必须用reg类型， 存储器存储单元8位长度， 共100个存储单元
7.
8. initial // 加载数据到存储器rom。 注意： 必须使用绝对路径， 如： E:/Xlinx/VivadoProject/ROM/（自己定）
9. begin
10. $readmemb ("D:/Xlinx/VivadoProject/CPU/rom_data.txt", rom); // 数据文件rom_data（.coe或.txt） 。 未指定， 就从0地址开始存放。
11. //rom[addr][7:0] = 1'b00000100;
12. dataOut = 0;
13. end
14.
15. always @( rd or addr ) begin
16. if (rd==1) begin // 为0， 读存储器。 大端数据存储模式
17. dataOut[31:24] = rom[addr];
18. dataOut[23:16] = rom[addr+1];
19. dataOut[15:8] = rom[addr+2];
20. dataOut[7:0] = rom[addr+3];
21. end
22. end
23. endmodule （3） ControlUnit
作用：根据PC传出的指令，设置相关的控制信号，相关信号的设置，详见实验原理中的控制信号作用表。相对于单周期CPU，增加了以下变量sign，WrRegDsrc，IRWre等，同时抛弃单周期CPU按照指令来更改控制信号，改成用所在的阶段来控制信号。
代码：
1. module ControlUnit(
2. input [5:0] op,
3. input zero,
4. input sign,
5. input clk,
6. input Reset,
7. output reg WrRegDSrc,
8. output reg PCWre,
9. output reg ALUSrcA,
10. output reg ALUSrcB,
11. output reg DBDataSrc,
12. output reg RegWre,
13. output reg InsMemRW,
14. output reg mRD,
15. output reg mWR,
16. output reg [1:0]RegDst,
17. output reg ExtSel,
18. output reg [1:0] PCSrc,
19. output reg [2:0] ALUOp,
20. output reg IRWre
21. ); （4） RegFile（寄存器组）
作用：暂时存储指令操作过程中产生的数据。按照实验的要求，设置成8位的寄存器。而且根据输入的读取数据的地址，读取对应寄存器的数据，并根据输入信号RegWre，确定是否能够对寄存器进行写入操作。当RegWre为0时，无法进行写入操作，当RegWre为1时，进行写入操作。与单周期相同。
代码：
1. module RegFile(CLK,RST,RegWre,ReadReg1,ReadReg2,WriteReg,WriteData,
2. ReadData1,ReadData2);
3. input CLK;
4. input RST;
5. input RegWre;
6. input [4:0] ReadReg1,ReadReg2,WriteReg;
7. input [31:0] WriteData;
8. output [31:0] ReadData1,ReadData2;
9.
10. reg [31:0] regFile[1:31]; // 寄存器定义必须用reg类型
11.
12. initial begin
13. for(i=1;i<32;i=i+1)
14. regFile[i] <= 0;
15. end
16. integer i;
17. assign ReadData1 = (ReadReg1 == 0) ? 0 : regFile[ReadReg1]; // 读寄存器数据
18. assign ReadData2 = (ReadReg2 == 0) ? 0 : regFile[ReadReg2];
19.
20. always @ (negedge CLK or negedge RST) begin // 必须用时钟边沿触发
21. if (RST==0) begin
22. for(i=1;i<32;i=i+1)
23. regFile[i] <= 0;
24. end
25. else if(RegWre == 1 && WriteReg != 0) // WriteReg != 0， $0寄存器不能修改
26. regFile[WriteReg] <= WriteData; // 写寄存器
27. end
28.
29. endmodule （5） ALU
作用：根据传入的控制信号，对传入的两个值进行相关的算术运算或逻辑运算，除了返回结果外，还有一个输出信号记录结果是否为0。相对于单周期CPU，不只是信号改变，还增加了sign来判断result的符号。
代码：
1. module ALU(
2. input [2:0] ALUopcode,
3. input [31:0] rega,
4. input [31:0] regb,
5. output reg [31:0] result,
6. output zero,
7. output sign
8. );
9. initial
10. begin
11. result = 0;
12. end
13. assign zero = (result==0)?1:0;
14. assign sign = result[31];
15. always @( ALUopcode or rega or regb ) begin
16. case (ALUopcode)
17. 3'b000 : result = rega + regb;
18. 3'b001 : result = rega - regb;
19. 3'b100 : result = regb << rega;
20. 3'b101 : result = rega | regb;
21. 3'b110 : result = rega & regb;
22. 3'b010 : result = (rega < regb)?1:0; // 不带符号比较
23. 3'b011 : begin // 带符号比较
24. if(rega < regb && (rega[31] == regb[31]))result = 1;
25. else if (rega[31] == 1 && regb[31] == 0) result = 1;
26. else result = 0;
27. end
28. 3'b111 : result = rega ^ regb;
29. default : begin
30. result = 32'h00000000;
31. $display (" no match");
32. end
33. endcase
34. end
35. endmodule
36. end
37. 3'b111 : result = rega ^ regb;
38. default : begin
39. result = 32'h00000000;
40. $display (" no match");
41. end
42. endcase
43. end
44. endmodule （6） RAM（数据存储器）
作用：按照要求，利用8位的寄存器来存储数据。根据传入的控制信号来进行读写操作。当nRD为1时，进行读取操作，当为0时，不进行读取操作，并输出高阻态；当nWR为0时，进行写入操作，当为1时，不进行写入操作。与单周期相同。
代码：
1. module RAM(
2. input clk,
3. input [31:0] address,
4. input [31:0] writeData, // [31:24], [23:16], [15:8], [7:0]
5. input nRD, // 为0， 正常读； 为1,输出高组态
6. input nWR, // 为1， 写； 为0， 无操作
7. output [31:0] Dataout
8. );
9.
10. reg [7:0] ram [0:60]; // 存储器定义必须用reg类型
11.
12. // 读
13. //assign是随时赋值语句，Data有变化，随时写进到ram中去
14. assign Dataout[7:0] = (nRD==1)?ram[address + 3]:8'bz; // z 为高阻态
15. assign Dataout[15:8] = (nRD==1)?ram[address + 2]:8'bz;
16. assign Dataout[23:16] = (nRD==1)?ram[address + 1]:8'bz;
17. assign Dataout[31:24] = (nRD==1)?ram[address ]:8'bz;
18. // 写
19. always@( negedge clk ) begin // 用时钟下降沿触发写存储器， 个例
20. if( nWR==0 ) begin
21. ram[address] <= writeData[31:24];
22. ram[address+1] <= writeData[23:16];
23. ram[address+2] <= writeData[15:8];
24. ram[address+3] <= writeData[7:0];
25. end
26. end
27. endmodule （7） Pccounter
作用：根据传入的信号，进行传入PC的新地址。当PCSrc为0时，新地址将读取下一条指令，即地址加4；当PCSrc为1时，在原有地址的基础上，跳转立即数的指令数目；当PCSrc为2时，跳转到j指令所指向的指令地址。相比于单周期，增加了一条通路，是寄存器31所指向的地址。
代码：
1. module PCcounter(
2. input [1:0] PCSrc,
3. input [31:0] currentAddress,
4. output reg [31:0] newAddress,
5. input [31:0] outData, readData1,//寄存器31的值
6. input [25:0] jAddress
7. );
8.
9. wire [31:0] temp_one, temp_two, temp_three;
10. assign temp_one = currentAddress + 4;
11. assign temp_two[25:0] = jAddress[25:0];
12. assign temp_three = temp_two << 2;
13. always@(PCSrc or currentAddress or outData or jAddress or temp_one)
14. begin
15. case(PCSrc)
16. 2'b00: newAddress = currentAddress+4;
17. 2'b01:
18. begin
19. newAddress = (currentAddress+4)+ (outData << 2);
20. newAddress[1:0] = 1'b00;
21. end
22. 2'b10:
23. begin
24. newAddress = readData1;//寄存器31的值
25. end
26. 2'b11:
27. begin
28. newAddress[31:28] = temp_one[31:28];
29. newAddress[27:0] = temp_three[27:0];
30. end
31. endcase
32. end
33. endmodule （8） Sign、zero extend
作用：根据传入的控制信号，对出入的数据进行相对应的拓展。当ExtSel为0时，对传入的立即数进行零拓展；当ExtSel为1时，对传入的立即数进行信号拓展。与单周期CPU相同。
代码：
1. module Extend(
2. input [15:0] immediate,
3. input ExtSel,
4. output reg[31:0] outData
5. );
6.
7. always@(immediate or ExtSel)
8. begin
9. case(ExtSel)
10. 1'b0:
11. begin
12. outData[15:0] = immediate;
13. outData[31:16] = 16'h0000;
14. end
15. 1'b1:
16. begin
17. outData[15:0] = immediate;
18. outData[31:16] = (immediate[15])? 16'hffff : 16'h0000;
19. end
20. endcase
21. end
22. endmodule （9） 5bit_selecter
作用：根据传入的控制信号，对两个传入的5位数据进行二选一操作。具体应用在选择rt或者rs作为写入地址。与单周期CPU相比，增加了一条通路，是关于写入寄存器31的选择。
代码：
1. module select_5_bit(
2. input [4:0] select_one,
3. input [4:0] select_two,
4. input [4:0] select_three,
5. input [1:0] control,
6. output reg[4:0] result
7. );
8.
9. //assign result = (control == 1'b0 ? select_one : select_two);
10. always@(control or select_one or select_two or select_three)
11. begin
12. case(control)
13. 2'b00: result <= select_one;
14. 2'b01: result <= select_two;
15. 2'b10: result <= select_three;
16. endcase
17. end
18. endmodule （10） 32bit_selecter
作用：根据传入的控制信号，对两个传入的32位数据进行二选一操作。具体应用在传入ALU的数据A的选择、传入ALU的数据B的选择以及写入寄存器中数据的选择。同单周期CPU。
代码：
1. module select_32_bit(
2. input [31:0] select_one,
3. input [31:0] select_two,
4. input control,
5. output [31:0] result
6. );
7.
8. assign result = (control == 1'b0 ? select_one : select_two);
9. endmodule （11） IR
作用：用于在sIF阶段，读取下一条指令，用于sID阶段的解析。由输入的控制信号，以及时钟的下降沿促发的。
代码：
1. module IR(
2. input [31:0] i_data,
3. input IRWre,
4. input clk,
5. output reg [31:0] o_data
6. );
7.
8. always @(negedge clk) begin
9. if(IRWre) o_data = i_data;
10. end
11.
12. endmodule （12） 数据延迟器（DataLate）
作用：一共有四处地方需要用到此模块，在于将大延迟切割成小延迟，主要是处于不同阶段间的转换。
代码：
1. module DataLate(
2. input [31:0] i_data,
3. input clk,
4. output reg [31:0] o_data
5. );
6.
7. always @(negedge clk) begin
8. o_data = i_data;
9. end
10.
11. endmodule 
其他具体的代码详见文章开头的代码包