MIPS單週期CPU的設計——I型指令的設計

一、一些概念

1.單週期CPU

       指令週期：CPU從內存取出一條指令並執行這條指令的時間總和。
       CPU週期：又稱機器週期，CPU訪問一次內存所花的時間較長，因此用從內存讀取一條指令字的最短時間來定義。
       時鐘週期：通常稱爲節拍脈衝或T週期。一個CPU週期包含若干個時鐘週期。
       指令週期>CPU週期>時鐘週期。
       單週期CPU：取出並執行一條指令在一個時鐘週期內完成，即一條指令用一個週期。MIPS就是一個單週期CPU。

2.MIPS指令格式和通用寄存器定義

       MIPS所有的指令均爲32位，MIPS指令的三種格式如下（op是指令碼）：

       R類型指令的op爲0，具體操作由func指定。rs和rt是源寄存器號，rd是目的寄存器號。只有移位指令使用sa來指定移位位數。I型指令的低16位是立即數，計算時要把它擴展到32位。依指令的不同，有零擴展和符號擴展兩種。零擴展是把32位的高16位置成0；符號位擴展是把高16位的每一位置成與立即數最高爲相同的值，即保持立即數的正負符號不變。J型指令的指令格式最簡單，右邊的26位是字地址，用於產生跳轉的目的地址。

       MIPS指令中的寄存器號（rs、rt和rd）有5位，因此它能訪問2^5=32個寄存器。下表列出了這32個寄存器的名稱和用途。

寄存器名	寄存器號	用途
$zero	0	常數0
$at	1	彙編器專用
$v0~$v1	2~3	表達式計算或者函數調用的返回結果
$a~$a3	4~7	函數調用參數1~3
$t0~$t7	8~15	臨時變量，函數調用時不需要保存和恢復
$s0~$s7	16~23	函數調用時需要保存和恢復的寄存器變量
$t8~$t9	24~25	臨時變量，函數調用時不需要保存和恢復
$k0~$k1	26~27	操作系統專用
$gp	28	全局變量指針（Global Poiner）
$sp	29	堆棧指針（Stack Pointer）
$fp	30	幀指針（Frame Pointer）
$ra	31	返回地址（Return Address）

       注意：
       ①0號寄存器的內容永遠是0。
       ②32號寄存器用來保存返回地址。
       上表雖然給出了使用這些寄存器的一些約定，但除了以上兩點，這些寄存器並無本質的區別。因此，描述這些寄存器時可以不使用帶有$的寄存器名，可以直接在r後面加寄存器號：r0，r1，…，r31。

二、MIPS CPU

       框圖：

       IF是取指模塊（Instruction Fetch），ID是譯碼模塊，InstMen是指存（指令存儲器）模塊，是一個Rom芯片，RagFile是寄存器堆，EX模塊是執行指令，包括寫指令（用來做運算，可以認爲是ALU）。

       I型指令的執行過程：
       IF的pc將指令的地址送入InstMem（指存）中，讀取相應指令，pc每過一個clk就會自加4（這個過程在IF裏完成），指向下一個指令。取出的指令送到ID ，ID將源寄存器的地址給regaAddress，將目的寄存器的地址給regcAddress（在I型指令中是這樣，其他指令裏就不一定了）,將ID中的regaAddress和regaRd（讀信號）送給RegFile，然後讀取數據RegFile中的regaData，將RegFile的regaData送給ID的regaData_i，regaData_i會作爲ID的regData送給EX。指令中的立即數也是可以在ID中直接獲得的，當regaRd無效時，就會將立即數的值進行擴展，然後送給regaData。
       而運算的功能是EX模塊來做的，所以ID讀取數據完成後，將數據regaData，和目的寄存器地址送給EX，op是操作碼，用來決定將進行何種操作，也送給EX。EX獲得數據和操作碼後就進行運算，運算後的結果存到regcData中，運算的結果也是要寫進RegFile中的，所以EX將regcData，regcAddr（要寫入的地址）和regcWr（寫信號）送給RegFile，將數據寫入寄存器堆保存起來，到這裏這條I型指令就執行完了。

       紅色的線是IF要做的事，藍色的是ID要做的事，綠色的是EX要做的事。

三、代碼設計

       IF、ID、EX和RegFile都是子模塊，我們需要寫一個MIPS模塊調用這幾個子模塊，InstMem是一個單獨的模塊，是在MIPS外面，MIPS和InstMem相結合就組成了一個更高一級的模塊，稱作Soc，我們可以寫一個Soc模塊調用MIPS和InstMem。

       I型指令很多，這裏只舉ori、addi、andi和xori指令的實現，每個模塊可以參照模塊圖進行理解。
       ①define.v

`define RstEnable       1'b1
`define RstDisable      1'b0
`define RomEnable       1'b1 
`define RomDisable      1'b0
`define RamWrEnable     1'b1
`define RamWrDisable    1'b0
`define Zero	        32'b0
`define Valid	        1'b1
`define Invalid	        1'b0

`define Inst_addi       6'b001000
`define Inst_andi       6'b001100
`define Inst_ori        6'b001101
`define Inst_xori       6'b001110
`define Inst_lui        6'b001111

`define Or              6'b000001
`define Add             6'b000010
`define And             6'b000100
`define Xor             6'b000101

`define Nop     6'b000000
`define Or      6'b000001

       ②IF.v

`include "define.v"
module IF(
    input wire clk,
    input wire rst,
    output reg romCe, 
output reg [31:0] pc
);
    always@(*)
        if(rst == `RstEnable)
            romCe = `RomDisable;
        else
            romCe = `RomEnable;
    always@(posedge clk)
        if(romCe == `RomDisable)
            pc = `Zero;
        else
            pc = pc + 4;
endmodule

       ③ID.v

`include "define.v"
module  ID (
    input wire rst,    
    input wire [31:0] inst,
    input wire [31:0] regaData_i,
    input wire [31:0] regbData_i,
    output reg [5:0] op,
    output reg [4:0] regaAddr,
    output reg [4:0] regbAddr,    
    output reg [4:0] regcAddr,    
    output reg [31:0] regaData,
    output reg [31:0] regbData,
    output reg regaRd,
    output reg regbRd,
    output reg regcWr  
);
    wire [5:0] inst_op = inst[31:26];    
    reg [31:0] imm;
    always@(*)
        if(rst == `RstEnable)
          begin
            op = `Nop;
            regaRd = `Invalid;
            regbRd = `Invalid;
            regcWr = `Invalid;
            regaAddr = `Zero;
            regbAddr = `Zero;
            regcAddr = `Zero;
            imm = `Zero;
          end
        else  
            case(inst_op)
                `Inst_ori:
                  begin
                    op = `Or;
                    regaRd = `Valid;
                    regbRd = `Invalid;
                    regcWr = `Valid;
                    regaAddr = inst[25:21];
                    regbAddr = `Zero;
                    regcAddr = inst[20:16];
                    imm = {16'h0, inst[15:0]};
                  end
                `Inst_addi:
                    begin
                        op = `Add;
                        regaRd = `Valid;
                        regbRd = `Invalid;
                        regcWr = `Valid;
                        regaAddr = inst[25:21];
                        regbAddr = `Zero;
                        regcAddr = inst[20:16];
                        imm = {16'b0,inst[15:0]};
                    end
                `Inst_andi:
                    begin
                        op = `And;
                        regaRd = `Valid;
                        regbRd = `Invalid;
                        regcWr = `Valid;
                        regaAddr = inst[25:21];
                        regbAddr = `Zero;
                        regcAddr = inst[20:16];
                        imm = {16'b0,inst[15:0]};
                    end
                `Inst_xori:
                    begin
                        op = `Xor;
                        regaRd = `Valid;
                        regbRd = `Invalid;
                        regcWr = `Valid;
                        regaAddr = inst[25:21];
                        regbAddr = `Zero;
                        regcAddr = inst[20:16];
                        imm = {16'b0,inst[15:0]};
                    end
                default:
                  begin
                    op = `Nop;
                    regaRd = `Invalid;
                    regbRd = `Invalid;
                    regcWr = `Invalid;
                    regaAddr = `Zero;
                    regbAddr = `Zero;
                    regcAddr = `Zero;
                    imm = `Zero;
                  end
            endcase
    always@(*)
      if(rst == `RstEnable)
          regaData = `Zero;
      else if(regaRd == `Valid)
          regaData = regaData_i;
      else
          regaData = imm;
    always@(*)
      if(rst == `RstEnable)
          regbData = `Zero;      
      else if(regbRd == `Valid)
          regbData = regbData_i;
      else
          regbData = imm; 
endmodule

       ④EX.v

`include "define.v"
module EX(
    input wire rst,
    input wire [5:0] op,    
    input wire [31:0] regaData,
    input wire [31:0] regbData,
    input wire regcWr_i,
    input wire [4:0]regcAddr_i,
    output reg [31:0] regcData,
    output wire regcWr,
    output wire [4:0] regcAddr
);    
    always@(*)
        if(rst == `RstEnable)
            regcData = `Zero;
        else
          begin
            case(op)
                `Or:
                    regcData = regaData | regbData;
                `Add:
                    regcData = regaData + regbData;
                `And:
                    regcData = regaData & regbData;
                `Xor:
                    regcData = regaData ^ regbData;
                default:
                    regcData = `Zero;
            endcase
          end
    assign regcWr = regcWr_i;
    assign regcAddr = regcAddr_i;
endmodule

       ⑤InstMem.v

`include "define.v"
module InstMem(
    input wire ce,
    input wire [31:0] addr,
    output reg [31:0] data
);
    reg [31:0] instmem [1023 : 0];    
    always@(*)      
        if(ce == `RomDisable)
          data = `Zero;
        else
          data = instmem[addr[11 : 2]];  //??????? 
    initial
      begin
        instmem [0] = 32'h34011100;//ori:32'h00000000 or 32'h00001100 =32'h00001100
        instmem [1] = 32'h20430000;//addi:32'h00000011 add 32'h00000000 = 32'h00000011
        instmem [2] = 32'h30850001;//andi:32'h00000001 and 32'h00000101 = 32'h00000001
        instmem [3] = 32'h38C70001;//xori:32'h00000001 xori 32'h00000011 = 32'h00000010
      end
endmodule

       ⑥RegFile.v

`include "define.v"
module RegFile(
    input wire clk,
    input wire rst,
    input wire we,
    input wire [4:0] waddr,
    input wire [31:0] wdata,
    input wire regaRd,
    input wire regbRd,
    input wire [4:0] regaAddr,
    input wire [4:0] regbAddr,
    output reg [31:0] regaData,
    output reg [31:0] regbData
);


    reg [31:0] reg32 [31 : 0];    
    always@(*)
        if(rst == `RstEnable)
            regaData = `Zero;
        else if(regaAddr == `Zero)
            regaData = `Zero;
        else
            regaData = reg32[regaAddr];
    always@(*)
        if(rst == `RstEnable)          
            regbData = `Zero;
        else if(regbAddr == `Zero)
            regbData = `Zero;
        else
            regbData = reg32[regbAddr];

    always@(*)
        if(we == `RamWrEnable)
            reg32[waddr] = wdata;
        else
            reg32[waddr] = `Zero;

    initial
        begin
            reg32[0] = 32'h00000001; //ori
            reg32[2] = 32'h00000011; //addi
            reg32[4] = 32'h00000101; //andi
            reg32[6] = 32'h00000011; //xori
        end  
endmodule

       ⑦MIPS.v

`include "define.v"
module MIPS(
    input wire clk,
    input wire rst,
    input wire [31:0] instruction,
    output wire romCe,
    output wire [31:0] instAddr
);
    wire [31:0] regaData_regFile, regbData_regFile;
    wire [31:0] regaData_id, regbData_id; 
    wire [31:0] regcData_ex;
    wire [5:0] op;    
    wire regaRd, regbRd;
    wire [4:0] regaAddr, regbAddr;
    wire regcWr_id, regcWr_ex;
    wire [4:0] regcAddr_id, regcAddr_ex;
    IF if0(
        .clk(clk),
        .rst(rst),
        .romCe(romCe), 
        .pc(instAddr)
    );
    ID id0(
        .rst(rst),        
        .inst(instruction),
        .regaData_i(regaData_regFile),
        .regbData_i(regbData_regFile),
        .op(op),
        .regaData(regaData_id),
        .regbData(regbData_id),
        .regaRd(regaRd),
        .regbRd(regbRd),
        .regaAddr(regaAddr),
        .regbAddr(regbAddr),
        .regcWr(regcWr_id),
        .regcAddr(regcAddr_id)
    );
    EX ex0(
        .rst(rst),
        .op(op),        
        .regaData(regaData_id),
        .regbData(regbData_id),
        .regcWr_i(regcWr_id),
        .regcAddr_i(regcAddr_id),
        .regcData(regcData_ex),
        .regcWr(regcWr_ex),
        .regcAddr(regcAddr_ex)
    );    
    RegFile regfile0(
        .clk(clk),
        .rst(rst),
        .we(regcWr_ex),
        .waddr(regcAddr_ex),
        .wdata(regcData_ex),
        .regaRd(regaRd),
        .regbRd(regbRd),
        .regaAddr(regaAddr),
        .regbAddr(regbAddr),
        .regaData(regaData_regFile),
        .regbData(regbData_regFile)
    );

endmodule

       ⑧Soc.v

module SoC(
    input wire clk,
    input wire rst
);
    wire [31:0] instAddr;
    wire [31:0] instruction;
    wire romCe;    
    MIPS mips0(
        .clk(clk),
        .rst(rst),
        .instruction(instruction),
        .instAddr(instAddr),
        .romCe(romCe)
    );    
    InstMem instrom0(
        .ce(romCe),
        .addr(instAddr),
        .data(instruction)
    );
endmodule

       ⑨soc_tb.v

`include "define.v"
module soc_tb;
    reg clk;
    reg rst;
    initial
      begin
        clk = 0;
        rst = `RstEnable;
        #100
        rst = `RstDisable;
        #10000 $stop;        
      end
    always #10 clk = ~ clk;
    SoC soc0(
        .clk(clk), 
        .rst(rst)
    );
endmodule

       仿真波形圖：

       由左到右指令1、2、3、4依次是ori指令、addi指令、andi指令、xori指令的測試數據以及結果。因爲沒有加MEM模塊，所以在EX中計算好的值，直接通過RegcData、RegcAddr和RegcWr三條線送入到RegFile裏的we、waddr和w的data。