[计算机组成原理][R-I-J型指令CPU设计实验总结] – 小飞侠

[计算机组成原理][R-I-J型指令CPU设计实验总结]

Post author:xfxia
Post published:2023年10月31日
Post category:其他

总算解决一大心头之患了，比想象中容易，通宵两夜，刷完了十个实验，这个实验就是最后的了。感慨颇多。特地写篇总结。

想做一件事，就立马去做把。你会发现没那么困难，往往最大的困难，是

心里的困难

。
培养了
HDL(Hardware Description Language)
思维，
并行
，
串行
混合。它先是一个
电路
，再才是一个
程序
，
电路
为主，
程序
为辅，用
RTL
的思维去思考。
这个实验也不怎么难，就是一个大的模拟题，当年ACM给我良好的代码功底受益颇多。
能硬件级别揣摩CPU的一点点运行方式，但是还有很多疑问，需要看书去解决。
这次的实验只是在心里面扎了一个种子（种子当然很重要啦~），需要看完CSAPP，和硬件/软件接口那两本书才能成长为苍天大树。
实验驱动型+看书解决型，现阶段最好的学习方法了~

以下是本次实验的
数据通路

module cpu

module cpu(clk,reset,ALU_OP,inst,rs,rt,rd,rs_data,rt_data,rd_data,ZF,OF,Write_Reg,PC,PC_new,rd_rt_s,W_Addr,imm,W_Data,imm_s,imm_data
,ALU_B,rt_imm_s,Mem_Write,M_R_Data,ALU_Data,alu_mem_s,w_r_s,wr_data_s,PC_s,address);
input wire clk;
input reset;
output [2:0] ALU_OP;    //操作符
output [31:0] inst;     //指令存放
output [4:0] rs;    //rs地址
output [4:0] rt;    //rt地址
output [4:0] rd;    //rd地址
output [31:0] rs_data;  //rs数据
output [31:0] rt_data;  //rt数据
output [31:0] rd_data;  //rd数据
output [31:0] PC;
output [31:0] PC_new;
output ZF;
output OF;
output Write_Reg;           //是否写入
output [31:0] W_Data;
output rd_rt_s; //控制那个作为目的寄存器
output [4:0]W_Addr;//目的操作数地址
output [15:0] imm; //立即数
output [31:0] imm_data;//被扩展的立即数
output imm_s;//是否需要扩展
output rt_imm_s;    //B端选择rt或者是imm
output [31:0] ALU_B;    //ALU_B端口数据
output Mem_Write;       //是否写入数据rom
output [31:0]M_R_Data;//从数据rom读出来的数据
output [31:0]ALU_Data;//ALU运算出来的结果,根据alu_mem_s选择由M_W_Data或者W_Data来赋值
output alu_mem_s;//看上面
output [1:0] w_r_s;
output [1:0] wr_data_s;
output [1:0] PC_s;//PC选择器
output [25:0] address;//地址解析数据
    //读指令
   ex7 pc (
  .clka(clk), 
  .douta(inst), 
  .rst(reset),
  .PC(PC),
  .PC_new(PC_new),
  .PC_s(PC_s),
  .R_Data_A(rs_data),
  .imm_data(imm_data),
  .address(address)
  //解析指令
  );
  analysis_inst analysis_inst(  
        .inst(inst),
        .ALU_OP(ALU_OP),
        .rs(rs),
        .rt(rt),
        .rd(rd),
        .Write_Reg(Write_Reg),
        .imm(imm),
        .rd_rt_s(rd_rt_s),
        .imm_s(imm_s),
        .rt_imm_s(rt_imm_s),
        .Mem_Write(Mem_Write),
        .alu_mem_s(alu_mem_s),
        .address(address),
        .w_r_s(w_r_s),
        .wr_data_s(wr_data_s),
        .PC_s(PC_s),
        .ZF(ZF)
    );
    //读取源操作数的值:
    assign W_Addr = (w_r_s[1])?5'b11111:((w_r_s[0])?rt:rd);
    assign imm_data = (imm_s)?{{16{imm[15]}},imm}:{{16{1'b0}},imm};

    reg1 Reg(
        .R_Addr_A(rs),
        .R_Addr_B(rt),
        .Clk(clk),
        .W_Addr(W_Addr),
        .W_Data(W_Data),    
        .R_Data_A(rs_data),
        .R_Data_B(rt_data),
        .Reset(reset),
        .Write_Reg(Write_Reg) //不写入
    );
    assign ALU_B=(rt_imm_s)?imm_data:rt_data;
    //对源操作数运算，存于目的操作数
    ex3 ALU(
    .ALU_OP(ALU_OP),
    .A(rs_data),
    .B(ALU_B),
    .F(ALU_Data),
    .ZF(ZF),
    .OF(OF)
    );
//----
wire clk_temp;
wire d_outn;
reg  d_out=0;
assign clk_temp = clk ^ d_out ;
assign d_outn = ~d_out ;
//----
always@(posedge clk_temp)
begin
  d_out <= d_outn ; 
end
    //数据存储器
    Data_Rom Datarom (
  .clka(clk_temp), // input clka
  .wea(Mem_Write), // input [0 : 0] wea
  .addra(ALU_Data[5:0]), // input [5 : 0] addra
  .dina(rt_data), // input [31 : 0] dina
  .douta(M_R_Data) // output [31 : 0] douta
);
    assign W_Data = (wr_data_s[1])?PC_new:(wr_data_s[0]?M_R_Data:ALU_Data);

endmodule

module pc

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date:    03:28:40 05/17/2016 
// Design Name: 
// Module Name:    ex7 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//
module ex7(clka,douta,rst,PC,PC_new,PC_s,R_Data_A,imm_data,address
    );
input rst;
input clka;
input [1:0] PC_s;
output  wire [31:0] douta;
output  reg [31:0] PC;
output   [31:0] PC_new;
input   [31:0] R_Data_A;
input   [31:0] imm_data;
input   [25:0] address;

wire [31:0]dina;
reg [0:0] wea=0;
assign PC_new=PC+4;

ex77 regrom (
  .clka(clka), // input clka
  .wea(wea), // input [0 : 0] wea
  .addra(PC[7:2]), // input [5 : 0] addra
  .dina(dina), // input [31 : 0] dina
  .douta(douta) // output [31 : 0] douta
);
always@(posedge rst or negedge clka)
begin 
    if(rst)
       PC<=32'h00000000;
    else 
        begin
            case(PC_s)
                2'b00: PC<=PC_new;
                2'b01: PC<=R_Data_A;
                2'b10: PC<=PC_new+(imm_data<<2);
                2'b11: PC<={PC_new[31:28],address,2'b00};
            endcase
        end
end
endmodule

module analysis_inst

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date:    07:31:58 05/17/2016 
// Design Name: 
// Module Name:    analysis_inst 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//
module analysis_inst(
inst,ALU_OP,rs,rt,rd,Write_Reg,imm,rd_rt_s,imm_s,rt_imm_s,Mem_Write,alu_mem_s,address,w_r_s,wr_data_s,PC_s,ZF
    );
input [31:0] inst;
output reg [2:0] ALU_OP;
output reg [4:0] rs;
output reg [4:0] rt;
output reg [4:0] rd;
output reg Write_Reg;
output reg [15:0] imm;
output reg rd_rt_s;
output reg imm_s;
output reg rt_imm_s;
output reg Mem_Write;
output reg alu_mem_s;
output reg [25:0] address;
output reg [1:0] w_r_s;
output reg [1:0] wr_data_s;
output reg [1:0] PC_s;
input  ZF;
always@(*)
begin
//--------------------处理R型指令----------------------
 if(inst[31:26]==6'b000000) //判断是否为R型
    begin
      rd=inst[15:11];       //rd
      rt=inst[20:16];       //rt
      rs=inst[25:21];       //rs
      w_r_s=2'b00;
      imm_s=0;//此处无所谓
      wr_data_s=2'b00;
      // alu_mem_s=0;//此处废弃不用，被wr_data_s替代
      Mem_Write=0;//是否写入数据存储器
      //rd_rt_s=0;//rd作为目的存储器//此处废弃不用吧被w_r_s替代
      rt_imm_s=0;//rt作为源操作数
      case(inst[5:0])   //映射对应的ALU
        6'b100000:begin ALU_OP=3'B100; Write_Reg=1;PC_s=2'b00;end
         6'b100010:begin ALU_OP=3'B101; Write_Reg=1;PC_s=2'b00;end
         6'b100100:begin ALU_OP=3'B000; Write_Reg=1;PC_s=2'b00;end
         6'b100101:begin ALU_OP=3'B001; Write_Reg=1;PC_s=2'b00;end
         6'b100110:begin ALU_OP=3'B010; Write_Reg=1;PC_s=2'b00;end
         6'b100111:begin ALU_OP=3'B011; Write_Reg=1;PC_s=2'b00;end
         6'b101011:begin ALU_OP=3'B110; Write_Reg=1;PC_s=2'b00;end 
         6'b000100:begin ALU_OP=3'B111; Write_Reg=1;PC_s=2'b00;end 
         6'b001000:begin ALU_OP=3'B100; Write_Reg=0;PC_s=2'b01;end
        endcase
     end
//------------------处理I型立即寻址指令------------------------   
  if(inst[31:29]==3'b001)
    begin
      imm=inst[15:0];
      rt=inst[20:16];       //rt
      rs=inst[25:21];       //rs
      Mem_Write=0;//是否写入数据存储器
      rd_rt_s=1;//rt作为目的存储器
      rt_imm_s=1;//imm作为源操作数
     // alu_mem_s=0;//以alu结果输出
      w_r_s=2'b01;
      Write_Reg=1;
      wr_data_s=2'b00;
      PC_s=2'b00;
      //判断属于那条指令
      case(inst[31:26])
      6'b001000: begin imm_s=1; ALU_OP=3'B100;end
      6'b001100: begin imm_s=0; ALU_OP=3'B000;end
      6'b001110: begin imm_s=0; ALU_OP=3'B010;end
      6'b001011: begin imm_s=0; ALU_OP=3'B110;end
      endcase
    end
//----------------处理I型取数/存数指令------------------
  if(inst[31:30]==2'b10&&inst[28:26]==3'b011)
    begin
      imm=inst[15:0];
      rt=inst[20:16];       //rt
      rs=inst[25:21];       //rs
      rd_rt_s=1;//rt作为目的存储器
      rt_imm_s=1;//imm作为源操作数
      imm_s=1;
      w_r_s=2'b01;
      wr_data_s=2'b01;
      PC_s=2'b00;
      //判断属于那条指令
      //读取数据时，以mem输出的数据写入，所以alu_mem_s=1;
      case(inst[31:26])
      6'b100011: begin alu_mem_s=1; Mem_Write=0;Write_Reg=1;ALU_OP=3'B100;end
      6'b101011: begin  Mem_Write=1;Write_Reg=0;ALU_OP=3'B100;end
      endcase
    end
//----------------处理I型跳转指令------------------------
    if(inst[31:27]==5'b00010)
     begin
      imm=inst[15:0];
      rt=inst[20:16];       //rt
      rs=inst[25:21];       //rs
     case(inst[31:26])
     6'b000100:begin rt_imm_s=0;ALU_OP=3'b101;Write_Reg=0;Mem_Write=0;PC_s=(ZF?2'b10:2'b00); end
     6'b000101:begin rt_imm_s=0;ALU_OP=3'b101;Write_Reg=0;Mem_Write=0;PC_s=(ZF?2'b00:2'b10); end
     endcase
     end
//----------------处理J型跳转指令-------------------------
    if(inst[31:27]==5'b00001)
     begin
     address=inst[25:0];
     case(inst[31:26])
     6'b000010:begin w_r_s=2'b00;Write_Reg=0;Mem_Write=0;PC_s=2'b11; end
     6'b000011:begin w_r_s=2'b10;wr_data_s=2'b10;Write_Reg=1;Mem_Write=0;PC_s=2'b11; end
     endcase
     end
end
endmodule

module Reg

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date:    00:34:10 05/17/2016 
// Design Name: 
// Module Name:    reg1 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//
module reg1(R_Addr_A,R_Addr_B,Clk,W_Addr,W_Data,R_Data_A,R_Data_B,Reset,Write_Reg
);
input Clk,Reset;
input wire Write_Reg;
input wire[4:0] R_Addr_A;
input wire[4:0] W_Addr;
input wire[4:0] R_Addr_B;
input wire[31:0] W_Data;
reg[31:0] REG_Files[31:0];
output wire[31:0] R_Data_A;
output wire[31:0] R_Data_B;

integer i=0;
always @(posedge Clk or posedge Reset)      //下降沿存储
begin
    if(Reset)   //初始化
    begin
        for(i=0;i<=31;i=i+1)
        REG_Files[i]<=32'h00000000;
    end
    else
        begin
            if(Write_Reg)
            REG_Files[W_Addr]<=W_Data;
        end
end
     assign R_Data_A=REG_Files[R_Addr_A];
    assign R_Data_B=REG_Files[R_Addr_B];
endmodule

module ALU

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date:    14:06:30 03/31/2016 
// Design Name: 
// Module Name:    ex3 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//
module ex3(ALU_OP,A,B,F,ZF,OF
);
input[2:0] ALU_OP;
input[31:0] A,B;
output reg [31:0] F;
output reg ZF,OF;
reg C32,C31;
reg [7:0]i;
always@(*)
begin

case(ALU_OP)
    3'b000:F=A&B;
    3'b001:F=A|B;
    3'b010:F=A^B;
    3'b011:F=~(A|B);
    3'b100:begin{C32,F}=A+B;OF=C32^A[31]^B[31]^F[31];end
    3'b101:begin{C32,F}=A-B;OF=C32^A[31]^B[31]^F[31];end
    3'b110:begin if(A<B)
                  F=1;
               else
                  F=0;
            end
    3'b111:F=B<<A;
    default: begin  end
    endcase

    ZF=((F==32'h00000000)?1:0);     
end
endmodule

版权声明：本文为zy691357966原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/zy691357966/article/details/51443025