计算机组成实验-第5章_R指令设计实现

/*主要问题，result=AopB，如果所有的always都是posedge clk触发，则会出现不同步的问题，因为A和B的值从寄存器取出进行运算得到结果之后，结果需要等到下一个时钟周期才能写入result：
     第一个时钟周期的操作是解析指令，将A和B的值从寄存器堆中取出，并且计算得到ALUoper的值。
     第二个时钟周期：计算result的值。
这样result会比A和B晚一个时钟周期。
因此，将ALUnit中的always改成*触发，这样：
     第一个时钟周期的操作是解析指令，将A和B的值从寄存器堆中取出，并且计算得到ALUoper的值，一旦三个值得到，计算结果会立刻写入result（得益于ALUnit中的always循环没有停顿）。
*/
//住模块代码
module Rtype(clk, rst, instru, Adat, Bdat, result);
     input clk;
     input rst;
     input [31:0] instru;
     output[31:0] result, Adat, Bdat;//Adat, Bdat为对应的两个操作数寄存器rs和rt，result对应rd
     wire [31:0] result;
    
     wire [31:0] Wdat, Adat, Bdat, ALUout;
     wire [2:0] ALUoper;
    
     RegFile s1(clk, instru[25:21], instru[20:16], instru[15:11],result, Adat, Bdat, 1);//生成子模块实例
     ALUctr s2(clk, 2'b10,instru[5:0],ALUoper);
     ALUnit s3(clk, Adat, Bdat, ALUoper, result, zero);

endmodule
module RegFile(clk, rs, rt, rd, result, A, B, RegWrite);//构建寄存器堆，并存取。
     input clk;
     input [4:0] rs, rt, rd;
     input [31:0] result;
     input RegWrite;
     output [31:0] A, B;
     reg [31:0] A, B;
    
     //下边是对应寄存器堆
     reg[31:0] Szero, Sat, Sv0, Sv1, Sa0, Sa1, Sa2, Sa3;//0-7
     reg[31:0] St0, St1, St2, St3, St4, St5, St6, St7;//8-15, Temp
     reg[31:0] Ss0, Ss1, Ss2, Ss3, Ss4, Ss5, Ss6, Ss7;//16-23, Saved
     reg[31:0] St8, St9, Sk0, Sk1, Sgp, Ssp, Sfp, Sra;//24-31
    
     //以下初值仅用于测试
     initial begin
          Szero = 0; Sat=1; Sv0=2; Sv1=3; Sa0=4; Sa1=5; Sa2=6; Sa3=7;
          St0=8; St1=9; St2=10; St3=11; St4=12; St5=13; St6=14; St7=15;
          Ss0=16; Ss1=17; Ss2=18; Ss3=19; Ss4=20; Ss5=21; Ss6=22; Ss7=23;
          St8=24; St9=25; Sk0=26; Sk1=27; Sgp=28; Ssp=29; Sfp=30; Sra=31;
     end
    
     //根据寄存器号取对应寄存器值（rs和rt）
     always @(posedge clk) begin
          case (rs)
               0:A=0; //$zero
               1:A=Sat;
               2:A=Sv0;
               3:A=Sv1;
               4:A=Sa0;
               5:A=Sa1;
               6:A=Sa2;
               7:A=Sa3;
               8:A=St0;
               9:A=St1;
               10:A=St2;
               11:A=St3;
               12:A=St4;
               13:A=St5;
               14:A=St6;
               15:A=St7;
               16:A=Ss0;
               17:A=Ss1;
               18:A=Ss2;
               19:A=Ss3;
               20:A=Ss4;
               21:A=Ss5;
               22:A=Ss6;
               23:A=Ss7;
               24:A=St8;
               25:A=St9;
               26:A=Sk0;
               27:A=Sk1;
               28:A=Sgp;
               29:A=Ssp;
               30:A=Sfp;
               31:A=Sra;         
          endcase
         
          case (rt)
               0:B=0;//$zero
               1:B=Sat;
               2:B=Sv0;
               3:B=Sv1;
               4:B=Sa0;
               5:B=Sa1;
               6:B=Sa2;
               7:B=Sa3;
               8:B=St0;
               9:B=St1;
               10:B=St2;
               11:B=St3;
               12:B=St4;
               13:B=St5;
               14:B=St6;
               15:B=St7;
               16:B=Ss0;
               17:B=Ss1;
               18:B=Ss2;
               19:B=Ss3;
               20:B=Ss4;
               21:B=Ss5;
               22:B=Ss6;
               23:B=Ss7;
               24:B=St8;
               25:B=St9;
               26:B=Sk0;
               27:B=Sk1;
               28:B=Sgp;
               29:B=Ssp;
               30:B=Sfp;
               31:B=Sra;
          endcase
         
          //write reg rd
          if (RegWrite == 1)
          case (rd)
               0:Szero=0;
               1:Sat=result;
               2:Sv0=result;
               3:Sv1=result;
               4:Sa0=result;
               5:Sa1=result;
               6:Sa2=result;
               7:Sa3=result;
               8:St0=result;
               9:St1=result;
               10:St2=result;
               11:St3=result;
               12:St4=result;
               13:St5=result;
               14:St6=result;
               15:St7=result;
               16:Ss0=result;
               17:Ss1=result;
               18:Ss2=result;
               19:Ss3=result;
               20:Ss4=result;
               21:Ss5=result;
               22:Ss6=result;
               23:Ss7=result;
               24:St8=result;
               25:St9=result;
               26:Sk0=result;
               27:Sk1=result;
               28:Sgp=result;
               29:Ssp=result;
               30:Sfp=result;
               31:Sra=result;
          endcase
     end
endmodule
//根据function field的值进行计算
module ALUnit(clk, A, B, ALUoper, result, zero);
     input clk;
     input [31:0] A, B;
     input [2:0] ALUoper;
    
     output zero;
     reg zero;
     output [31:0] result;
     reg [31:0] result;
    
     always @(*) begin/*always @(posedge clk) begin 会有延迟，计算结果不能立刻写入result，也不能立刻写入寄存器堆。*/
          case (ALUoper)
               3'b000: result = A & B;
               3'b001: result = A | B;
               3'b010: result = A + B;
               3'b110: result = A - B;
               3'b111: result = (A<B)?1:0;
               default: result = A + B;//Add
          endcase
          zero = (A==B)?1:0;
     end
endmodule
 //为什么有些地方always @ (*)会出问题。。
 
 
module ALUctr(clk, ALUop, Func, op);
     input clk;
     input [1:0] ALUop;
     input [5:0] Func;
     output [2:0] op;
     reg[2:0] op;
    
     always @(posedge clk) begin// 如果改成always @(*) begin会出现不同步的问题。
          case (ALUop[1])
               1'b0:case (ALUop[0])
                    1'b0:op<=3'b010;
                    1'b1:op<=3'b110;
                    endcase
               1'b1:case (Func)
                    6'b100000:op<=3'b010;
                    6'b100010:op<=3'b110;
                    6'b100100:op<=3'b000;
                    6'b100101:op<=3'b001;
                    6'b101010:op<=3'b111;
                    endcase
          endcase
     end
endmodule


//测试代码，可以再仿真中修改数字显示的格式（二进制、十进制等），还可以修改时间窗口的长短。
module test;
  reg clk = 1'b0;
    reg rst = 1'b0;
    reg [31:0] I = 32'b00000000000000000000000000000000;
    wire [31:0] A;
    wire [31:0] B;
    wire [31:0] result;
    parameter PERIOD = 20;//时钟周期长短
    parameter real DUTY_CYCLE = 0.5;
    parameter OFFSET = 0;
    initial    // Clock process for clk
    begin
        #OFFSET;
        forever//10ns，clk会翻转一次
        begin
            clk = 1'b0;
            #(PERIOD-(PERIOD*DUTY_CYCLE)) clk = 1'b1;
            #(PERIOD*DUTY_CYCLE);
        end
    end
    Rtype UUT (
        .clk(clk),
        .rst(rst),
        .instru(I),
        .Adat(A),
        .Bdat(B),
        .result(result));//将A作为子模块输入，对应子模块里边的Adat
    initial begin
        // -------------  Current Time:  105ns
        #105;
        rst = 1'b1;
        // -------------------------------------
        // -------------  Current Time:  405ns
        #300;
        I = 32'b00000001101010001000000000100000;
        // -------------------------------------
        // -------------  Current Time:  1405ns
        #1000;
        I = 32'b00000001110010011000100000100010;
        // -------------------------------------
        // -------------  Current Time:  2405ns
        #1000;
        I = 32'b00000001111010101001000000100100;
        // -------------------------------------
        // -------------  Current Time:  3405ns
        #1000;
        I = 32'b00000011000010111001100000100101;
        // -------------------------------------
        // -------------  Current Time:  4405ns
        #1000;
        I = 32'b00000011001011001010000000101010;
        // -------------------------------------
    end
      
endmodule