• cpu设计和实现（流水线上的第一条指令）

    【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】

            读书的时候，《计算机组成原理》也看了，《计算机体系结构》也学了，老师也给我们讲了各种各样的流水线知识，但是实践的机会很少，感觉就是没有把理论转成实际的东西。工作之后，倒是有机会接触各种各样的开源代码，这里面也包括了开源cpu代码，比如openrisc（https://github.com/openrisc/or1200/tree/master/rtl/verilog）这样的开源代码。但是内容又过于复杂，学习的曲线比较陡，难度很高。所以至此，很多同学就云里雾里不知道流水线和cpu的指令是怎么完成的，总是搞不清楚。

            前面分析过，一条指令的过程是按照取指、译码、执行、访存、写回这5个步骤来完成的。那么今天，就可以用一条5级流水线来实现ori指令。

    1、 题外话的一个知识点

            之前我们在编写取指那篇文章的时候，谈到过组合逻辑和时序逻辑的区别。很多刚学verilog的同学，很容易把wire看成是组合逻辑，把reg看成是时序逻辑，这是不对的。是组合逻辑，还是时序逻辑，归根到底还是要看触发条件，比如之前的那个代码，我们稍微调整下，

    1. module test(clk, rst, in, out_a, out_b);
    2.  
    3. input wire clk;
    4. input wire rst;
    5. input wire in;
    6.  
    7. output wire out_a;
    8. output reg out_b;
    9.  
    10. assign out_a = in;
    11.  
    12. always@(*) begin
    13. 	if(rst) 
    14. 		out_b <= 1'b0;
    15. 	else 
    16. 		out_b <= in;
    17. end
    19. endmodule

             这里的out_b从类型上看，好像是register。但是它的触发条件却是always(*)，这就意味着，在这段电路描述中，只要rst或者in发生改变，out_b就会随之改变。这不就是组合逻辑的思路吗？同样，可以借助于gtkwave观察下图形确认一下，

             简单分析下，这里的out_b在rst置位的时候，一直输出为0。但是当rst撤去之后，out_b就开始随着in的改变而改变。这个示例告诉我们，组合逻辑和时序逻辑，最终都要通过触发条件来进行区别和判断。如果心里还是拿不准，就仿真看一下波形图结果就好了。

    2、流水线编写

            注1：关于本章所有的verilog代码，参考这个地址，https://github.com/feixiaoxing/design_mips_cpu/tree/master/rtl/day03 。

            注2：文中涉及代码，来自于《自己动手写cpu》，向原作者雷思磊表示感谢。

    2.1 取指if

            取指这部分之前已经描述过了（https://feixiaoxing.blog.csdn.net/article/details/127914989?spm=1001.2014.3001.5502）。主要包含了两个部分，一个是地址的生成，一个是rom数据的读取。做好了这两个，取指的工作就完成了。其中，地址pc生成是时序逻辑，rom读取是组合逻辑。

    2.2 指令传递if-id

            指令传送是一个时序逻辑。在这个模块，需要把指令传递给下一个模块，内容不复杂，

    1. `include "defines.v"
    2.  
    3. module if_id(
    4. 	input wire clk,
    5. 	input wire rst,
    6. 	
    7. 	input wire[`InstAddrBus] if_pc,
    8. 	input wire[`InstBus] if_inst,
    9. 	output reg[`InstAddrBus] id_pc,
    10. 	output reg[`InstBus] id_inst
    11. );
    12.  
    13. always @(posedge clk) begin
    14. 	if(rst == `RstEnable) begin
    15. 		id_pc <= `ZeroWord;
    16. 		id_inst <= `ZeroWord;
    17. 	end else begin
    18. 		id_pc <= if_pc;
    19. 		id_inst <= if_inst;
    20. 	end
    21. end
    22.  
    23.  
    24. endmodule

    2.3 译码id

            译码是流水线中很重要的工作。它主要的目的，就是从指令数据中提取到合适的信息。比如当前操作是寄存器操作，还是访存操作。如果是寄存器操作，是逻辑运算，还是数学运算。如果是逻辑运算，源操作数1是哪个，源操作数2是哪个，目的操作数是哪个，是什么样的逻辑运算等等。

            另外，在译码的过程中，对cpu通用寄存器的操作也是很重要的，这部分可以看一下，

    1. `include "defines.v"
    2.  
    3. module regfile(
    4. 	input wire clk,
    5. 	input wire rst,
    6. 	
    7. 	// write
    8. 	input wire we,
    9. 	input wire[`RegAddrBus] waddr,
    10. 	input wire[`RegBus]  wdata,
    11. 	
    12. 	// read1
    13. 	input wire re1,
    14. 	input wire[`RegAddrBus] raddr1,
    15. 	output reg[`RegBus] rdata1,
    16. 	
    17. 	// read2
    18. 	input wire re2,
    19. 	input wire[`RegAddrBus] raddr2,
    20. 	output reg[`RegBus] rdata2
    21. );
    22.  
    23. reg[`RegBus] regs[0:`RegNum-1];
    24.  
    25. always @(posedge clk) begin
    26. 	if(rst == `RstDisable) begin 
    27. 		if((we == `WriteEnable) && (waddr!= `RegNumLog2'h0)) begin
    28. 			regs[waddr] <= wdata; 
    29. 		end
    30. 	end
    31. end
    33. always@(*) begin
    34. 	if(rst == `RstEnable) begin
    35. 		rdata1 <= `ZeroWord;
    36. 	end else if(raddr1 == `RegNumLog2'h0) begin
    37. 		rdata1 <= `ZeroWord;
    38. 	end else if((raddr1 == waddr) && (we == `WriteEnable) && (re1 == `ReadEnable)) begin
    39. 		rdata1 <= wdata;
    40. 	end else if(re1 == `ReadEnable) begin
    41. 		rdata1 <= regs[raddr1];
    42. 	end else begin
    43. 		rdata1 <= `ZeroWord;
    44. 	end
    45. end
    46.  
    47. always@(*) begin
    48. 	if(rst == `RstEnable) begin
    49. 		rdata2 <= `ZeroWord;
    50. 	end else if(raddr2 == `RegNumLog2'h0) begin
    51. 		rdata2 <= `ZeroWord;
    52. 	end else if((raddr2 == waddr) && (we == `WriteEnable) && (re2 == `ReadEnable)) begin
    53. 		rdata2 <= wdata;
    54. 	end else if(re2 == `ReadEnable) begin
    55. 		rdata2 <= regs[raddr1];
    56. 	end else begin
    57. 		rdata2 <= `ZeroWord;
    58. 	end
    59. end
    62. endmodule

            从代码上看，regfile最多支持两个register的读取和一个register的写入。注意，这里读取动作是组合逻辑，写入动作是时序逻辑，这非常重要。此外，不管寄存器是这样，rom操作、ram操作也是这样，读取一般都是组合逻辑，而写入才是时序逻辑。

            说完了寄存器访问，下面就是具体的译码工作了，

    1. `include "defines.v"
    2.  
    3. module id(
    4. 	input wire rst,
    5. 	input wire[`InstAddrBus] pc_i,
    6. 	input wire[`InstBus] inst_i,
    7. 	
    8. 	input wire[`RegBus] reg1_data_i,
    9. 	input wire[`RegBus] reg2_data_i,
    10. 	
    11. 	output reg reg1_read_o, // read signal
    12. 	output reg reg2_read_o, // read signal
    13. 	output reg[`RegAddrBus] reg1_addr_o,
    14. 	output reg[`RegAddrBus] reg2_addr_o,
    15. 	
    16. 	output reg[`AluOpBus] aluop_o,
    17. 	output reg[`AluSelBus] alusel_o,
    18. 	output reg[`RegBus] reg1_o,
    19. 	output reg[`RegBus] reg2_o,
    20. 	output reg[`RegAddrBus] wd_o,
    21. 	output reg wreg_o
    22. );
    23.  
    24. wire[5:0] op = inst_i[31:26];
    25. wire [4:0] op2 = inst_i[10:6];
    26. wire [5:0] op3 = inst_i[5:0];
    27. wire [4:0] op4 = inst_i[20:16];
    28.  
    29. reg[`RegBus] imm;
    30.  
    31. reg instvalid;
    32.  
    33.  
    34. always @(*) begin
    35. 	if(rst == `RstEnable) begin
    36. 		aluop_o <= `EXE_NOP_OP;
    37. 		alusel_o <= `EXE_RES_NOP;
    38. 		wd_o <= `NOPRegAddr;
    39. 		wreg_o <= `WriteDisable;
    40. 		instvalid <= `InstValid;
    41. 		reg1_read_o <= 1'b0;
    42. 		reg2_read_o <= 1'b0;
    43. 		reg1_addr_o <= `NOPRegAddr;
    44. 		reg2_addr_o <= `NOPRegAddr;
    45. 		imm <= 32'h0;
    46. 	end else begin
    47. 		aluop_o <= `EXE_NOP_OP;
    48. 		alusel_o <= `EXE_RES_NOP;
    49. 		wd_o <= inst_i[15:11];
    50. 		wreg_o <= `WriteDisable;
    51. 		instvalid <= `InstValid;
    52. 		reg1_read_o <= 1'b0;
    53. 		reg2_read_o <= 1'b0;
    54. 		reg1_addr_o <= inst_i[25:21];
    55. 		reg2_addr_o <= inst_i[20:16];
    56. 		imm <= `ZeroWord;
    57. 		
    58. 		case(op)
    59. 			`EXE_ORI: begin
    60. 				wreg_o <= `WriteEnable;
    61. 				aluop_o <= `EXE_OR_OP;
    62. 				alusel_o <= `EXE_RES_LOGIC;
    63. 				reg1_read_o <= 1'b1;
    64. 				reg2_read_o <= 1'b0;
    65. 				imm <= {16'h0, inst_i[15:0]};
    66. 				wd_o <= inst_i[20:16];
    67. 				instvalid <= `InstValid;
    68. 			end
    69. 			
    70. 			default: begin
    71. 			end
    72. 		endcase
    73. 	end
    74. end
    75.  
    76. always @(*) begin
    77. 	if(rst == `RstEnable) begin
    78. 		reg1_o <= `ZeroWord;
    79. 	end else if(reg1_read_o == 1'b1) begin
    80. 		reg1_o <= reg1_data_i;
    81. 	end else if(reg1_read_o == 1'b0) begin
    82. 		reg1_o <= imm;
    83. 	end else begin
    84. 		reg1_o <= `ZeroWord;
    85. 	end
    86. end
    87.  
    88. always @(*) begin
    89. 	if(rst == `RstEnable) begin
    90. 		reg2_o <= `ZeroWord;
    91. 	end else if(reg2_read_o == 1'b1) begin
    92. 		reg2_o <= reg2_data_i;
    93. 	end else if(reg2_read_o == 1'b0) begin
    94. 		reg2_o <= imm;
    95. 	end else begin
    96. 		reg2_o <= `ZeroWord;
    97. 	end
    98. end	
    99.  
    100.  
    101.  
    102. endmodule

            译码的工作其实也分成了两个部分。一部分，就是之前讨论的指令解析。这里分析的指令是EXE_ORI，所以看到wreg_o、aluop_o、alusel_o等这样的赋值动作。另一部分，就是寄存器的读取动作，至于reg1_o和reg_o是访存register寄存器，还是直接从imm立即数中获取，这取决于具体的情况。就EXE_ORI而言，reg1_o来自于reg1_data_i，reg2_o来自于imm。

    2.4 操作数传递id-exe

            操作数的传递也是一个时序逻辑。它的主要功能就是把读取到的操作数、操作方式、写入地址告诉exe模块，

    1. `include "defines.v"
    2.  
    3. module id_ex(
    4.  
    5. 	input wire clk,
    6. 	input wire rst,
    7. 	
    8. 	input wire[`AluOpBus]   id_aluop,
    9. 	input wire[`AluSelBus]  id_alusel,
    10. 	input wire[`RegBus]     id_reg1,
    11. 	input wire[`RegBus]     id_reg2,
    12. 	input wire[`RegAddrBus] id_wd,
    13. 	input wire              id_wreg,
    14. 	
    15. 	output reg[`AluOpBus]   ex_aluop,
    16. 	output reg[`AluSelBus]  ex_alusel,
    17. 	output reg[`RegBus]     ex_reg1,
    18. 	output reg[`RegBus]     ex_reg2,
    19. 	output reg[`RegAddrBus] ex_wd,
    20. 	output reg              ex_wreg
    21. );
    22.  
    23.  
    24. always @(posedge clk) begin
    25. 	if(rst == `RstEnable) begin
    26. 		ex_aluop <= `EXE_NOP_OP;
    27. 		ex_alusel <= `EXE_RES_NOP;
    28. 		ex_reg1 <= `ZeroWord;
    29. 		ex_reg2 <= `ZeroWord;
    30. 		ex_wd <= `NOPRegAddr;
    31. 		ex_wreg <= `WriteDisable;
    32. 	end else begin
    33. 		ex_aluop <= id_aluop;
    34. 		ex_alusel <= id_alusel;
    35. 		ex_reg1 <= id_reg1;
    36. 		ex_reg2 <= id_reg2;
    37. 		ex_wd <= id_wd;
    38. 		ex_wreg <= id_wreg;
    39. 	end
    40. end
    41.  
    42. endmodule

    2.5 执行exe

            有了从id模块获取的操作数和写入地址，这里只要完成对应的操作就可以。注意，执行exe属于组合逻辑，

    1. `include "defines.v"
    2.  
    3. module ex(
    4. 	input wire rst,
    5. 	
    6. 	input wire[`AluOpBus] aluop_i,
    7. 	input wire[`AluSelBus] alusel_i,
    8. 	input wire[`RegBus] reg1_i,
    9. 	input wire[`RegBus] reg2_i,
    10. 	input wire[`RegAddrBus] wd_i,
    11. 	input wire wreg_i,
    12. 	
    13. 	output reg[`RegAddrBus] wd_o,
    14. 	output reg wreg_o,
    15. 	output reg[`RegBus] wdata_o
    16. );
    17.  
    18. reg[`RegBus] logicout;
    19.  
    20. always@(*) begin
    21. 	if(rst == `RstEnable) begin
    22. 		logicout <= `ZeroWord;
    23. 	end else begin
    24. 		case (aluop_i)
    25. 			`EXE_OR_OP: begin
    26. 				logicout <= reg1_i | reg2_i;
    27. 			end
    28.  
    29. 			default: begin
    30. 				logicout <= `ZeroWord;
    31. 			end
    32. 		endcase
    33. 	end
    34. end
    35.  
    36. always@(*) begin
    37. 	wd_o <= wd_i;
    38. 	wreg_o <= wreg_i;
    39. 	
    40. 	case(alusel_i)
    41. 		`EXE_RES_LOGIC: begin
    42. 			wdata_o <= logicout;
    43. 		end
    44. 		default: begin
    45. 			wdata_o <= `ZeroWord;
    46. 		end
    47. 	endcase
    48. end
    49.  
    50.  
    51. endmodule

            因为exe中可能会有逻辑运算、数学运算、移位运算等等，所以一般这里都会先进行一下区分，最后把结果汇总上来。如上面的代码所示，logicout就是汇总之前的计算，而最终输出的数据时wdata_o。

    2.6 执行传递ex-mem

            做完了exe，下面就需要把结果传递给mem这个模块了。也许有同学说，这里不是不需要访存吗，为什么还要传递给mem。这主要是因为之前设计的就是5级流水线，即使最终用不到这一块内容，也需要透传一下。

    1. `include "defines.v"
    2.  
    3. module ex_mem(
    4. 	input wire clk,
    5. 	input wire rst,
    6. 	
    7. 	input wire[`RegAddrBus] ex_wd,
    8. 	input wire ex_wreg,
    9. 	input wire[`RegBus] ex_wdata,
    10.  
    11. 	output reg[`RegAddrBus] mem_wd,
    12. 	output reg mem_wreg,
    13. 	output reg[`RegBus] mem_wdata
    14. 	
    15. );
    16.  
    17. always @(posedge clk) begin	
    18. 	if(rst ==`RstEnable) begin
    19. 		mem_wd <= `NOPRegAddr;
    20. 		mem_wreg <= `WriteDisable;
    21. 		mem_wdata <= `ZeroWord;
    22. 	end else begin
    23. 		mem_wd <= ex_wd;
    24. 		mem_wreg <= ex_wreg;
    25. 		mem_wdata <= ex_wdata;
    26. 	end
    27. end
    28.  
    29. endmodule

    2.7 访问mem

            之前说过，这部分其实不需要，只是流水线已经设计好，所以需要的操作就是继续透传下去。接着，我们可以看下verilog代码，

    1. `include "defines.v"
    2.  
    3. module mem(
    4. 	input wire rst,
    5. 	
    6. 	input wire[`RegAddrBus] wd_i,
    7. 	input wire wreg_i,
    8. 	input wire[`RegBus] wdata_i,
    9.  
    10. 	output reg[`RegAddrBus] wd_o,
    11. 	output reg wreg_o,
    12. 	output reg[`RegBus] wdata_o
    13. 	
    14. );
    15.  
    16. always @(*) begin	
    17. 	if(rst ==`RstEnable) begin
    18. 		wd_o <= `NOPRegAddr;
    19. 		wreg_o <= `WriteDisable;
    20. 		wdata_o <= `ZeroWord;
    21. 	end else begin
    22. 		wd_o <= wd_i;
    23. 		wreg_o <= wreg_i;
    24. 		wdata_o <= wdata_i;
    25. 	end
    26. end
    27.  
    28. endmodule

    2.8 访存传递mem-wb

            有了mem阶段的处理，这部分就可以正式交给wb了。需要注意的是，mem访问是组合逻辑，而mem-wb是时序逻辑。

    1. `include "defines.v"
    2.  
    3. module mem_wb(
    4. 	input wire clk,
    5. 	input wire rst,
    6. 	
    7. 	input wire[`RegAddrBus] mem_wd,
    8. 	input wire mem_wreg,
    9. 	input wire[`RegBus] mem_wdata,
    10.  
    11. 	output reg[`RegAddrBus] wb_wd,
    12. 	output reg wb_wreg,
    13. 	output reg[`RegBus] wb_wdata
    14. 	
    15. );
    16.  
    17. always @(posedge clk) begin	
    18. 	if(rst ==`RstEnable) begin
    19. 		wb_wd <= `NOPRegAddr;
    20. 		wb_wreg <= `WriteDisable;
    21. 		wb_wdata <= `ZeroWord;
    22. 	end else begin
    23. 		wb_wd <= mem_wd;
    24. 		wb_wreg <= mem_wreg;
    25. 		wb_wdata <= mem_wdata;
    26. 	end
    27. end
    28.  
    29. endmodule

    2.9  wb写回

            很多同学会问，问什么没有wb写回的组合逻辑和时序逻辑。一般来说，wb阶段就是把数据直接写到寄存器里面，这个阶段一般是不会有什么问题的。而写回的数据、寄存器地址，直接给regfile这个模块就可以了，大家可以从openmips.v这个文件看的出来，

    1. `include "defines.v"
    2.  
    3. module openmips(
    4. 	input wire clk,
    5. 	input wire rst,
    6. 	
    7. 	input wire[`RegBus] rom_data_i,
    8. 	output wire[`RegBus] rom_addr_o,
    9. 	output wire rom_ce_o
    10. );
    11.  
    12. wire[`InstAddrBus] pc;
    13. wire[`InstAddrBus] id_pc_i;
    14. wire[`InstBus] id_inst_i;
    15.  
    16. wire[`AluOpBus] id_aluop_o;
    17. wire[`AluSelBus] id_alusel_o;
    18. wire[`RegBus] id_reg1_o;
    19. wire[`RegBus] id_reg2_o;
    20. wire id_wreg_o;
    21. wire[`RegAddrBus] id_wd_o;
    22.  
    23. wire[`AluOpBus] ex_aluop_i;
    24. wire[`AluSelBus] ex_alusel_i;
    25. wire[`RegBus] ex_reg1_i;
    26. wire[`RegBus] ex_reg2_i;
    27. wire ex_wreg_i;
    28. wire[`RegAddrBus] ex_wd_i;
    29.  
    30. wire ex_wreg_o;
    31. wire[`RegAddrBus] ex_wd_o;
    32. wire[`RegBus] ex_wdata_o;
    33.  
    34. wire mem_wreg_i;
    35. wire[`RegAddrBus] mem_wd_i;
    36. wire[`RegBus] mem_wdata_i;
    37.  
    38. wire mem_wreg_o;
    39. wire[`RegAddrBus] mem_wd_o;
    40. wire[`RegBus] mem_wdata_o;
    41.  
    42. wire wb_wreg_i;
    43. wire[`RegAddrBus] wb_wd_i;
    44. wire[`RegBus] wb_wdata_i;
    45.  
    46. wire reg1_read;
    47. wire reg2_read;
    48. wire[`RegBus] reg1_data;
    49. wire[`RegBus] reg2_data;
    50. wire[`RegAddrBus] reg1_addr;
    51. wire[`RegAddrBus] reg2_addr;
    52.  
    53. // initialize pc_reg
    54. pc_reg pc_reg0(
    55. 	.clk(clk),
    56. 	.rst(rst),
    57. 	.pc(pc),
    58. 	.ce(rom_ce_o)
    59. );
    60.  
    61. assign rom_addr_o = pc;
    62.  
    63.  
    64. // initialize if_id
    65.  
    66. if_id if_id0(
    67. 	.clk(clk),
    68. 	.rst(rst),
    69. 	
    70. 	.if_pc(pc),
    71. 	.if_inst(rom_data_i),
    72. 	
    73. 	.id_pc(id_pc_i),
    74. 	.id_inst(id_inst_i)
    75. );
    76.  
    77. // initialize id
    78. id id0(
    79. 	.rst(rst),
    80. 	.pc_i(id_pc_i),
    81. 	.inst_i(id_inst_i),
    82. 	
    83. 	.reg1_data_i(reg1_data),
    84. 	.reg2_data_i(reg2_data),
    85. 	
    86. 	.reg1_read_o(reg1_read),
    87. 	.reg2_read_o(reg2_read),
    88. 	.reg1_addr_o(reg1_addr),
    89. 	.reg2_addr_o(reg2_addr),
    90. 	
    91. 	.aluop_o(id_aluop_o),
    92. 	.alusel_o(id_alusel_o),
    93. 	.reg1_o(id_reg1_o),
    94. 	.reg2_o(id_reg2_o),
    95. 	.wd_o(id_wd_o),
    96. 	.wreg_o(id_wreg_o)
    97. );
    98.  
    99. // initialize regfile
    100.  
    101. regfile regfile1(
    102. 	.clk(clk),
    103. 	.rst(rst),
    104. 	
    105. 	.we(wb_wreg_i),
    106. 	.waddr(wb_wd_i),
    107. 	.wdata(wb_wdata_i),
    108. 	
    109. 	.re1(reg1_read),
    110. 	.raddr1(reg1_addr),
    111. 	.rdata1(reg1_data),
    112. 	
    113. 	.re2(reg2_read),
    114. 	.raddr2(reg2_addr),
    115. 	.rdata2(reg2_data)
    116. );
    117.  
    118. // initialize idid_ex
    119.  
    120. id_ex id_ex0(
    121. 	.clk(clk),
    122. 	.rst(rst),
    123. 	
    124. 	.id_aluop(id_aluop_o),
    125. 	.id_alusel(id_alusel_o),
    126. 	.id_reg1(id_reg1_o),
    127. 	.id_reg2(id_reg2_o),
    128. 	.id_wd(id_wd_o),
    129. 	.id_wreg(id_wreg_o),
    130. 	
    131. 	.ex_aluop(ex_aluop_i),
    132. 	.ex_alusel(ex_alusel_i),
    133. 	.ex_reg1(ex_reg1_i),
    134. 	.ex_reg2(ex_reg2_i),
    135. 	.ex_wd(ex_wd_i),
    136. 	.ex_wreg(ex_wreg_i)
    137. );
    138.  
    139. // initialize ex
    140.  
    141. ex ex0(
    142. 	.rst(rst),
    143. 	
    144. 	.aluop_i(ex_aluop_i),
    145. 	.alusel_i(ex_alusel_i),
    146. 	.reg1_i(ex_reg1_i),
    147. 	.reg2_i(ex_reg2_i),
    148. 	.wd_i(ex_wd_i),
    149. 	.wreg_i(ex_wreg_i),
    150. 	
    151. 	.wd_o(ex_wd_o),
    152. 	.wreg_o(ex_wreg_o),
    153. 	.wdata_o(ex_wdata_o)
    154. );
    155.  
    156.  
    157. // initialize ex_mem
    158.  
    159.  
    160. ex_mem ex_mem0(
    161.  
    162. 	.clk(clk),
    163. 	.rst(rst),
    164. 	
    165. 	.ex_wd(ex_wd_o),
    166. 	.ex_wreg(ex_wreg_o),
    167. 	.ex_wdata(ex_wdata_o),
    168. 	
    169. 	.mem_wd(mem_wd_i),
    170. 	.mem_wreg(mem_wreg_i),
    171. 	.mem_wdata(mem_wdata_i)
    172.  
    173. );
    174.  
    175.  
    176.  
    177. // initialize mem
    178.  
    179. mem mem0(
    180.  
    181. 	.rst(rst),
    182. 	
    183. 	.wd_i(mem_wd_i),
    184. 	.wreg_i(mem_wreg_i),
    185. 	.wdata_i(mem_wdata_i),
    186. 	
    187. 	.wd_o(mem_wd_o),
    188. 	.wreg_o(mem_wreg_o),
    189. 	.wdata_o(mem_wdata_o)
    190.  
    191. );
    192.  
    193. // initialize mem_wb
    194.  
    195. mem_wb mem_wb0(
    196.  
    197. 	.clk(clk),
    198. 	.rst(rst),
    199. 	
    200. 	.mem_wd(mem_wd_o),
    201. 	.mem_wreg(mem_wreg_o),
    202. 	.mem_wdata(mem_wdata_o),
    203. 	
    204. 	.wb_wd(wb_wd_i),
    205. 	.wb_wreg(wb_wreg_i),
    206. 	.wb_wdata(wb_wdata_i)
    207.  
    208. );
    209.  
    210. endmodule
    211.

            直接观察wb_wd_i、wb_wreg_i、wb_wdata_i这几个信号，最终是返回给了regfile1这个模块，这也从形式上面完成了流水线的闭环操作。

    2.10 仿真和测试

            为了仿真和测试，需要做两步。第一步，给openmips准备一个小的soc模块，把cpu和rom加进去，比如像这样，

    1. `include "defines.v"
    2.  
    3. module openmips_min_sopc(
    4.  
    5. 	input wire clk,
    6. 	input wire rst
    7. );
    8.  
    9. wire[`InstAddrBus] inst_addr;
    10. wire [`InstBus] inst;
    11. wire rom_ce;
    12.  
    13. openmips openmips0(
    14. 	.clk(clk),
    15. 	.rst(rst),
    16. 	.rom_addr_o(inst_addr),
    17. 	.rom_data_i(inst),
    18. 	.rom_ce_o(rom_ce)
    19. );
    20.  
    21. inst_rom inst_rom0(
    22. 	.ce(rom_ce),
    23. 	.addr(inst_addr),
    24. 	.inst(inst)
    25. );
    26.  
    27.  
    28. endmodule

            其次，给这个soc模块准备一个testbench测试，发一下激励信号。

    1.  
    2. `timescale 1ns/1ns
    3.  
    4. module openmips_min_sopc_tb();
    5.  
    6. reg CLOCK_50;
    7. reg rst;
    8.  
    9. initial begin
    10. 	CLOCK_50 = 1'b0;
    11. 	forever #10 CLOCK_50=~CLOCK_50;
    12. end
    13.  
    14. initial begin 
    15. 	rst = `RstEnable;
    16. 	#195 rst = `RstDisable;
    17. 	#1000 $stop;
    18. end
    19.  
    20. openmips_min_sopc openmips_min_sopc0(
    21. 	.clk(CLOCK_50),
    22. 	.rst(rst)
    23. );
    24.  
    25. initial
    26. begin
    27.     $dumpfile("hello.vcd");
    28.     $dumpvars(0, openmips_min_sopc_tb);
    29. end
    30.  
    31. endmodule

            注意，测试romdata也发生了变化，

    1. 34011100
    2. 34020020
    3. 3403ff00
    4. 3404ffff

            有了这两步，就可以用iverilog和gtkwave开始测试了，

            上面的图形中，其实regfile1的部分没有显示出来，可以通过regfile.v中添加一些代码，比如这样，

    1. wire[0:31] regs0_wire;
    2. wire[0:31] regs1_wire;
    3. wire[0:31] regs2_wire;
    4. wire[0:31] regs3_wire;
    5. assign regs0_wire = regs[0];
    6. assign regs1_wire = regs[1];
    7. assign regs2_wire = regs[2];
    8. assign regs3_wire = regs[3];

            这样波形图就看的比较清楚了，

     

    3、调试方法

            调试的时候，可以优先测试register，也就是时序逻辑。如果时序逻辑没有问题，再对组合逻辑进行问题和验证。测试往往是一个循环往复的过程，需要不断进行，更需要找到root cause。

  • 相关阅读:
    需求分析和常见的需求问题解决
    极智开发 | 讲解 React 组件三大属性之三：refs
    【MySQL】事务的概念、特性及其分类
    [DOM]获取元素：根据ID、标签名、HTML5新增的方法、特殊元素获取
    电子章盖章软件怎么找？从需求、功能、成本、口碑四方面入手
    滴滴秋招提前批正式开始,现在投递免笔试
    【无标题】
    Simulink从0搭建模型03-Enabled Subsystem 使能子系统
    Qlik部署动态经营分析，实时帮助企业掌控盈利能力
    C++算法之旅、09 力扣篇 | 常见面试笔试题（上）算法小白专用
  • 原文地址：https://blog.csdn.net/feixiaoxing/article/details/127932768