MIPS Branch Target Buffer动态分支预测（BTB）

最新推荐文章于 2024-08-01 21:59:33 发布
最新推荐文章于 2024-08-01 21:59:33 发布
阅读量3.2k 收藏 13
点赞数
分类专栏： FPGA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40268672/article/details/108566283
版权

MIPS代码：

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/07/23 15:31:35
// Design Name: 
// Module Name: MIPS
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module MIPS(
input clk,
input rst
    );
reg [31:0] RegFile [0:31];
reg [31:0] IMEM [0:255];
reg [31:0] DMEM [0:255];

integer i;
initial
begin
    for(i=0;i<256;i=i+1)
        DMEM[i]=i;
end

initial
begin
    for(i=0;i<32;i=i+1)
        RegFile[i]<=i;
end

initial
begin
    IMEM[0]=32'h00240820;
    IMEM[4]=32'h01024022;
    IMEM[8]=32'h1100fffd;
    IMEM[12]=32'h00c72820;
    IMEM[16]=32'h014b4820;
    IMEM[20]=32'h01ae6020;
    IMEM[24]=32'h02117820;
end

wire IF2ID_Write;
wire PCWrite;
wire ID2EXE_Stall;
wire [31:0]ALUSrcA;                  
wire [31:0]ALUSrcB;
wire [1:0]ForwardA;
wire [1:0]ForwardB;
wire [4:0]IF2ID_rs;
wire [4:0]IF2ID_rt;
wire [31:0]MEM2WB_Data;
wire FlushIF;
wire FlushID;
wire FlushEXE;

assign FlushIF=(EXE2MEM_Branch==1'b1&&(EXE2MEM_ALUOut!=EXE2MEM_predicted))?1'b1:1'b0;           //若预测错误，则flush之前的3条指令
assign FlushID=(EXE2MEM_Branch==1'b1&&(EXE2MEM_ALUOut!=EXE2MEM_predicted))?1'b1:1'b0;
assign FlushEXE=(EXE2MEM_Branch==1'b1&&(EXE2MEM_ALUOut!=EXE2MEM_predicted))?1'b1:1'b0;

reg wr_req;
reg [31:0]wr_PC;
reg [31:0]wr_predicted_PC;
reg wr_predicted_state_bit;
reg [31:0]rd_PC;

wire rd_predicted_PC;
wire rd_predicted;

reg IF2ID_predicted;
reg ID2EXE_predicted;
reg EXE2MEM_predicted;


//更新BTB
always@(*)
if(EXE2MEM_Branch)
    if(EXE2MEM_ALUOut==1'b0&&EXE2MEM_predicted==1'b1)     //预测taken但不taken
    begin
        wr_req=1'b1;
        wr_PC=EXE2MEM_NPC-32'd4;
        wr_predicted_PC=EXE2MEM_BranchPC;
        wr_predicted_state_bit=1'b0;
    end
    else if(EXE2MEM_ALUOut==1'b1&&EXE2MEM_predicted==1'b0)    //预测不taken但taken
    begin
        wr_req=1'b1;
        wr_PC=EXE2MEM_NPC-32'd4;
        wr_predicted_PC=EXE2MEM_BranchPC;
        wr_predicted_state_bit=1'b1;
    end
    else
    begin
        wr_req=1'b0;
        wr_PC=EXE2MEM_NPC-32'd4;
        wr_predicted_PC=EXE2MEM_BranchPC;
        wr_predicted_state_bit=1'b0;
    end
else
begin
    wr_req=1'b0;
    wr_PC=EXE2MEM_NPC-32'd4;
    wr_predicted_PC=EXE2MEM_BranchPC;
    wr_predicted_state_bit=1'b0;
end
//传递rd_predicted,即预测结果，以与之后的实际结果相比较
always@(posedge clk,posedge rst)
if(rst)
begin
    IF2ID_predicted<=1'b0;
    ID2EXE_predicted<=1'b0;
    EXE2MEM_predicted<=1'b0;
end
else
begin
    IF2ID_predicted<=rd_predicted;
    ID2EXE_predicted<=IF2ID_predicted;
    EXE2MEM_predicted<=ID2EXE_predicted;
end


//IF
reg [31:0] PC;
reg [31:0] IF2ID_NPC;
reg [31:0] IF2ID_IR;
//ID
reg [4:0]ID2EXE_rs;                //Rs寄存器号 约定大写为数据，小写为寄存器�?
reg [4:0]ID2EXE_rt;                //Rt寄存器号
reg [4:0]ID2EXE_rd;                //Rd寄存器号
reg [31:0]ID2EXE_Rs;               //Rs寄存器内�?
reg [31:0]ID2EXE_Rt;               //Rt寄存器内�?
reg [31:0]ID2EXE_Imm;              //符号扩展后的立即�?
reg [31:0]ID2EXE_NPC;                  

reg ID2EXE_RegDst;
reg ID2EXE_ALUSrc;
reg ID2EXE_MemRead;
reg ID2EXE_MemWrite;
reg ID2EXE_Branch;
reg ID2EXE_MemtoReg;
reg ID2EXE_RegWrite;
reg [1:0] ID2EXE_ALUOp;
//EXE
reg [31:0]EXE2MEM_ALUOut;
reg [31:0]EXE2MEM_BranchPC;
reg [31:0]EXE2MEM_Rt;
reg [4:0]EXE2MEM_RegRd;                    //WB阶段写寄存器�?

reg EXE2MEM_MemRead;
reg EXE2MEM_MemWrite;
reg EXE2MEM_Branch;
reg EXE2MEM_MemtoReg;
reg EXE2MEM_RegWrite;
reg [31:0]EXE2MEM_NPC;
//MEM
reg [31:0]MEM2WB_LDM;
reg [31:0]MEM2WB_ALUOut;
reg [4:0]MEM2WB_RegRd;

reg MEM2WB_RegWrite;
reg MEM2WB_MemtoReg;

/****************************************************************************************/

assign IF2ID_rs=IF2ID_IR[25:21];
assign IF2ID_rt=IF2ID_IR[20:16];
assign MEM2WB_Data=(MEM2WB_MemtoReg)?MEM2WB_LDM:MEM2WB_ALUOut;

//IF
BTB V(
.clk(clk),
.rst(rst),
.rd_PC(PC),
.rd_predicted(rd_predicted),
.rd_predicted_PC(rd_predicted_PC),
.wr_req(wr_req),
.wr_PC(wr_PC),
.wr_predicted_PC(wr_predicted_PC),
.wr_predicted_state_bit(wr_predicted_state_bit)
);

always@(posedge clk,posedge rst)
begin
if(rst)
begin
    PC<=32'd0;
    IF2ID_NPC<=32'd0;
    IF2ID_IR<=32'd0;
end
else
begin
    if(PCWrite)
    begin
        if(EXE2MEM_Branch)
            if(EXE2MEM_predicted==1'b1&&EXE2MEM_ALUOut==1'b0)           //预测taken但实际没tabke
                PC<=EXE2MEM_NPC;
            else if(EXE2MEM_predicted==1'b0&&EXE2MEM_ALUOut==1'b1)      //预测not taken但实际taken
                PC<=EXE2MEM_BranchPC;
            else if(rd_predicted)
                PC<=rd_predicted_PC;
            else
                PC<=PC+32'd4;
        else if(rd_predicted)
            PC<=rd_predicted_PC;
        else
            PC<=PC+32'd4;
    end
    else
        PC<=PC;
    if(FlushIF)
    begin
        IF2ID_NPC<=32'd0;
        IF2ID_IR<=32'd0;
    end
    else if(IF2ID_Write)
    begin
        IF2ID_NPC<=PC+4;
        IF2ID_IR<=IMEM[PC];
    end
    
    else
    begin
        IF2ID_NPC<=IF2ID_NPC;
        IF2ID_IR<=IF2ID_IR;
    end
end
end

//ID
HAZARD_DETECTION U1(
.ID2EXE_MemRead(ID2EXE_MemRead),
.IF2ID_rs(IF2ID_rs),
.IF2ID_rt(IF2ID_rt),
.ID2EXE_rt(ID2EXE_rt),
.PCWrite(PCWrite),
.ID2EXE_Stall(ID2EXE_Stall),
.IF2ID_Write(IF2ID_Write)
);

always@(posedge clk,posedge rst)
if(rst)
begin
    ID2EXE_RegDst<=1'b0;
    ID2EXE_ALUSrc<=1'b0;
    ID2EXE_ALUOp<=2'b00;
    ID2EXE_MemRead<=1'b0;
    ID2EXE_MemWrite<=1'b0;
    ID2EXE_Branch<=1'b0;
    ID2EXE_RegWrite<=1'b0;
    ID2EXE_MemtoReg<=1'b0;
end
else if(ID2EXE_Stall||FlushID)
begin
    ID2EXE_RegDst<=1'b0;
    ID2EXE_ALUSrc<=1'b0;
    ID2EXE_ALUOp<=2'b00;
    ID2EXE_MemRead<=1'b0;
    ID2EXE_MemWrite<=1'b0;
    ID2EXE_Branch<=1'b0;
    ID2EXE_RegWrite<=1'b0;
    ID2EXE_MemtoReg<=1'b0;
end
else
case(IF2ID_IR[31:26])
6'b000000:begin
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b100100010;
end
6'b100011:begin
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b011110000;
end
6'b101011:begin
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b010001000;
end
6'b000100:begin
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b000000101;
end
default:
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b000000000;
endcase

always@(posedge clk,posedge rst)
if(rst)
begin
    ID2EXE_rs<=5'd0;
    ID2EXE_rt<=5'd0;
    ID2EXE_rd<=5'd0;
    ID2EXE_Rs<=32'd0;
    ID2EXE_Rt<=32'd0;
    ID2EXE_Imm<=32'd0;
    ID2EXE_NPC<=32'd0;
end
else if(FlushID)
begin
    ID2EXE_rs<=5'd0;
    ID2EXE_rt<=5'd0;
    ID2EXE_rd<=5'd0;
    ID2EXE_Rs<=32'd0;
    ID2EXE_Rt<=32'd0;
    ID2EXE_Imm<=32'd0;
    ID2EXE_NPC<=32'd0;
end
else
begin
    ID2EXE_rs<=IF2ID_IR[25:21];
    ID2EXE_rt<=IF2ID_IR[20:16];
    ID2EXE_rd<=IF2ID_IR[15:11];
    ID2EXE_Rs<=RegFile[IF2ID_IR[25:21]];
    ID2EXE_Rt<=RegFile[IF2ID_IR[20:16]];
    ID2EXE_Imm<={{16{IF2ID_IR[15]}},IF2ID_IR[15:0]};
    ID2EXE_NPC<=IF2ID_NPC;
end

//EXE

FORWARDING U2(
.ID2EXE_rs(ID2EXE_rs),
.ID2EXE_rt(ID2EXE_rt),
.EXE2MEM_RegRd(EXE2MEM_RegRd),
.MEM2WB_RegRd(MEM2WB_RegRd),
.EXE2MEM_RegWrite(EXE2MEM_RegWrite),
.MEM2WB_RegWrite(MEM2WB_RegWrite),
.ForwardA(ForwardA),
.ForwardB(ForwardB)
);
//ALUSrcA三�?�一
mux3_1 U3(
.a(ID2EXE_Rs),
.b(EXE2MEM_ALUOut),
.c(MEM2WB_Data),
.select(ForwardA),
.out(ALUSrcA)
);
//ALUSrcB
mux3_1 U4(
.a(ID2EXE_Rt),
.b(EXE2MEM_ALUOut),
.c(MEM2WB_Data),
.select(ForwardB),
.out(ALUSrcB)
);

always@(posedge clk,posedge rst)
if(rst)
begin
    EXE2MEM_MemRead<=1'b0;
    EXE2MEM_MemWrite<=1'b0;
    EXE2MEM_Branch<=1'b0;
    EXE2MEM_MemtoReg<=1'b0;
    EXE2MEM_RegWrite<=1'b0;
end
else if(FlushEXE)
begin
    EXE2MEM_MemRead<=1'b0;
    EXE2MEM_MemWrite<=1'b0;
    EXE2MEM_Branch<=1'b0;
    EXE2MEM_MemtoReg<=1'b0;
    EXE2MEM_RegWrite<=1'b0;
end
else
begin
    EXE2MEM_MemRead<=ID2EXE_MemRead;
    EXE2MEM_MemWrite<=ID2EXE_MemWrite;
    EXE2MEM_Branch<=ID2EXE_Branch;
    EXE2MEM_MemtoReg<=ID2EXE_MemtoReg;
    EXE2MEM_RegWrite<=ID2EXE_RegWrite;
end

always@(posedge clk,posedge rst)
if(rst)
begin
    EXE2MEM_ALUOut<=32'd0;
    EXE2MEM_RegRd<=5'd0;
    EXE2MEM_Rt<=32'd0;
    EXE2MEM_BranchPC<=32'd0;
    EXE2MEM_NPC<=32'd0;
end
else
begin
    EXE2MEM_RegRd<=(ID2EXE_RegDst)?ID2EXE_rd:ID2EXE_rt;
    EXE2MEM_Rt<=ALUSrcB;               //ID2EXE_Rt or forwarded from EXE2MEM or forwarded from MEM2WB
    EXE2MEM_BranchPC<=ID2EXE_NPC+(ID2EXE_Imm<<2);
    EXE2MEM_NPC<=ID2EXE_NPC;
    case(ID2EXE_ALUOp)
        2'b00:EXE2MEM_ALUOut<=ALUSrcA+ID2EXE_Imm;          //lw or sw
        2'b01:EXE2MEM_ALUOut<=(ALUSrcA!=ALUSrcB)?1:0;
        2'b10:
        case (ID2EXE_Imm[5:0])
            6'b100000:EXE2MEM_ALUOut<=ALUSrcA+ALUSrcB;
            6'b100010:EXE2MEM_ALUOut<=ALUSrcA-ALUSrcB;
            6'b100100:EXE2MEM_ALUOut<=ALUSrcA&ALUSrcB;
            6'b100101:EXE2MEM_ALUOut<=ALUSrcA|ALUSrcB;
            6'b101010:EXE2MEM_ALUOut<=(ALUSrcA<ALUSrcB)?1:0;
        default: EXE2MEM_ALUOut<=EXE2MEM_ALUOut;
        endcase
        default:
            EXE2MEM_ALUOut<=EXE2MEM_ALUOut;
    endcase
end

//MEM
always@(posedge clk,posedge rst)
if(rst)
begin
    MEM2WB_RegWrite<=1'b0;
    MEM2WB_MemtoReg<=1'b0;
end
else
begin
    MEM2WB_RegWrite<=EXE2MEM_RegWrite;
    MEM2WB_MemtoReg<=EXE2MEM_MemtoReg;
end

always@(posedge clk,posedge rst)
if(rst)
begin
    MEM2WB_LDM<=32'd0;
    MEM2WB_ALUOut<=32'd0;
    MEM2WB_RegRd<=5'd0;
end
else
begin
    MEM2WB_ALUOut<=EXE2MEM_ALUOut;
    MEM2WB_RegRd<=EXE2MEM_RegRd;
    if(EXE2MEM_MemRead)
        MEM2WB_LDM<=DMEM[EXE2MEM_ALUOut];
    else if(EXE2MEM_MemWrite)
        DMEM[EXE2MEM_ALUOut]<=EXE2MEM_Rt;
end

//WB
always@(negedge clk,posedge rst)
if(rst)
    ;
else if(MEM2WB_RegWrite)
    if(MEM2WB_MemtoReg)
        RegFile[MEM2WB_RegRd]<=MEM2WB_LDM;
    else
        RegFile[MEM2WB_RegRd]<=MEM2WB_ALUOut;
        
endmodule

BTB代码：

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/09/11 19:02:52
// Design Name: 
// Module Name: BTB
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module BTB(
input  clk, rst,

input [31:0] rd_PC,					//输入PC
output reg rd_predicted,			//对外输出的信号, 表示rd_PC是跳转指令，此时rd_predicted_PC是有效数据
output reg [31:0] rd_predicted_PC,	//从buffer中得到的预测PC
input wr_req,						//写请求信号
input [31:0] wr_PC,					//要写入的分支PC
input [31:0] wr_predicted_PC,		//要写入的预测PC
input wr_predicted_state_bit		//要写入的预测状态位
    );
parameter BUFFER_ADDR_LEN=4;
parameter BUFFER_SIZE=1<<BUFFER_ADDR_LEN;
parameter TAG_LEN=32-BUFFER_ADDR_LEN-2;

reg [TAG_LEN-1:0] tag_pc [0:BUFFER_SIZE-1]; 
reg [31:0] predicted_pc [0:BUFFER_SIZE-1];
reg predicted_state [0:BUFFER_SIZE-1];

wire [TAG_LEN-1:0] rd_pc_tag;
wire [BUFFER_ADDR_LEN-1:0] rd_pc_index;
wire [1:0] rd_pc_offset;
wire [TAG_LEN-1:0] wr_pc_tag;
wire [BUFFER_ADDR_LEN-1:0] wr_pc_index;
wire [1:0] wr_pc_offset;

assign {rd_pc_tag,rd_pc_index,rd_pc_offset}=rd_PC;
assign {wr_pc_tag,wr_pc_index,wr_pc_offset}=wr_PC;

always@(*)
if(tag_pc[rd_pc_index]==rd_pc_tag&&predicted_state[rd_pc_index]==1'b1)
    rd_predicted=1'b1;
else
    rd_predicted=1'b0;

always@(*)
   rd_predicted_PC=predicted_pc[rd_pc_index];

//write buffer,update
integer i;
always@(posedge clk,posedge rst)
if(rst)
begin
    for(i=0;i<BUFFER_SIZE;i=i+1)
    begin
        tag_pc[i]<=0;
        predicted_pc[i]<=0;
        predicted_state[i]<=0;
    end
end
else if(wr_req)
begin
    tag_pc[wr_pc_index]<=wr_pc_tag;
    predicted_pc[wr_pc_index]<=wr_predicted_PC;
    predicted_state[wr_pc_index]<=wr_predicted_state_bit;
end
endmodule

其余模块代码见链接
之前的MIPS代码有问题，在更新PC时，若预测错误，则PC更新为新的跳转地址的优先级应该高于因load-use数据冒险而产生的阻塞（Stall），现代码更改如下：

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/07/23 15:31:35
// Design Name: 
// Module Name: MIPS
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module MIPS(
input clk,
input rst
    );
reg [31:0] RegFile [0:31];
reg [31:0] IMEM [0:255];
reg [31:0] DMEM [0:255];

integer i;
initial
begin
    for(i=0;i<256;i=i+1)
        DMEM[i]=i;
end

initial
begin
    for(i=0;i<32;i=i+1)
        RegFile[i]<=i;
end

initial
begin
    IMEM[0]=32'h8c810004;
    IMEM[4]=32'h00211820;
    IMEM[8]=32'h00c23022;
    IMEM[12]=32'h10c0fffc;
    IMEM[16]=32'h012a4020;
    IMEM[20]=32'h01ac5822;
    IMEM[24]=32'h01f07020;
end

wire IF2ID_Write;
wire PCWrite;
wire ID2EXE_Stall;
wire [31:0]ALUSrcA;                  
wire [31:0]ALUSrcB;
wire [1:0]ForwardA;
wire [1:0]ForwardB;
wire [4:0]IF2ID_rs;
wire [4:0]IF2ID_rt;
wire [31:0]MEM2WB_Data;
wire FlushIF;
wire FlushID;
wire FlushEXE;

assign FlushIF=(EXE2MEM_Branch==1'b1&&(EXE2MEM_ALUOut!=EXE2MEM_predicted))?1'b1:1'b0;           //若预测错误，则flush之前的3条指令
assign FlushID=(EXE2MEM_Branch==1'b1&&(EXE2MEM_ALUOut!=EXE2MEM_predicted))?1'b1:1'b0;
assign FlushEXE=(EXE2MEM_Branch==1'b1&&(EXE2MEM_ALUOut!=EXE2MEM_predicted))?1'b1:1'b0;

reg wr_req;
reg [31:0]wr_PC;
reg [31:0]wr_predicted_PC;
reg wr_predicted_state_bit;
reg [31:0]rd_PC;

wire rd_predicted_PC;
wire rd_predicted;

reg IF2ID_predicted;
reg ID2EXE_predicted;
reg EXE2MEM_predicted;


//更新BTB
always@(*)
if(EXE2MEM_Branch)
    if(EXE2MEM_ALUOut==1'b0&&EXE2MEM_predicted==1'b1)     //预测taken但不taken
    begin
        wr_req=1'b1;
        wr_PC=EXE2MEM_NPC-32'd4;
        wr_predicted_PC=EXE2MEM_BranchPC;
        wr_predicted_state_bit=1'b0;
    end
    else if(EXE2MEM_ALUOut==1'b1&&EXE2MEM_predicted==1'b0)    //预测不taken但taken
    begin
        wr_req=1'b1;
        wr_PC=EXE2MEM_NPC-32'd4;
        wr_predicted_PC=EXE2MEM_BranchPC;
        wr_predicted_state_bit=1'b1;
    end
    else
    begin
        wr_req=1'b0;
        wr_PC=EXE2MEM_NPC-32'd4;
        wr_predicted_PC=EXE2MEM_BranchPC;
        wr_predicted_state_bit=1'b0;
    end
else
begin
    wr_req=1'b0;
    wr_PC=EXE2MEM_NPC-32'd4;
    wr_predicted_PC=EXE2MEM_BranchPC;
    wr_predicted_state_bit=1'b0;
end
//传递rd_predicted,即预测结果，以与之后的实际结果相比较
always@(posedge clk,posedge rst)
if(rst)
begin
    IF2ID_predicted<=1'b0;
    ID2EXE_predicted<=1'b0;
    EXE2MEM_predicted<=1'b0;
end
else
begin
    IF2ID_predicted<=rd_predicted;
    ID2EXE_predicted<=IF2ID_predicted;
    EXE2MEM_predicted<=ID2EXE_predicted;
end


//IF
reg [31:0] PC;
reg [31:0] IF2ID_NPC;
reg [31:0] IF2ID_IR;
//ID
reg [4:0]ID2EXE_rs;                //Rs寄存器号 约定大写为数据，小写为寄存器�?
reg [4:0]ID2EXE_rt;                //Rt寄存器号
reg [4:0]ID2EXE_rd;                //Rd寄存器号
reg [31:0]ID2EXE_Rs;               //Rs寄存器内�?
reg [31:0]ID2EXE_Rt;               //Rt寄存器内�?
reg [31:0]ID2EXE_Imm;              //符号扩展后的立即�?
reg [31:0]ID2EXE_NPC;                  

reg ID2EXE_RegDst;
reg ID2EXE_ALUSrc;
reg ID2EXE_MemRead;
reg ID2EXE_MemWrite;
reg ID2EXE_Branch;
reg ID2EXE_MemtoReg;
reg ID2EXE_RegWrite;
reg [1:0] ID2EXE_ALUOp;
//EXE
reg [31:0]EXE2MEM_ALUOut;
reg [31:0]EXE2MEM_BranchPC;
reg [31:0]EXE2MEM_Rt;
reg [4:0]EXE2MEM_RegRd;                    //WB阶段写寄存器�?

reg EXE2MEM_MemRead;
reg EXE2MEM_MemWrite;
reg EXE2MEM_Branch;
reg EXE2MEM_MemtoReg;
reg EXE2MEM_RegWrite;
reg [31:0]EXE2MEM_NPC;
//MEM
reg [31:0]MEM2WB_LDM;
reg [31:0]MEM2WB_ALUOut;
reg [4:0]MEM2WB_RegRd;

reg MEM2WB_RegWrite;
reg MEM2WB_MemtoReg;

/****************************************************************************************/

assign IF2ID_rs=IF2ID_IR[25:21];
assign IF2ID_rt=IF2ID_IR[20:16];
assign MEM2WB_Data=(MEM2WB_MemtoReg)?MEM2WB_LDM:MEM2WB_ALUOut;

//IF
BTB V(
.clk(clk),
.rst(rst),
.rd_PC(PC),
.rd_predicted(rd_predicted),
.rd_predicted_PC(rd_predicted_PC),
.wr_req(wr_req),
.wr_PC(wr_PC),
.wr_predicted_PC(wr_predicted_PC),
.wr_predicted_state_bit(wr_predicted_state_bit)
);

always@(posedge clk,posedge rst)
begin
if(rst)
begin
    PC<=32'd0;
    IF2ID_NPC<=32'd0;
    IF2ID_IR<=32'd0;
end
else
begin
    if(EXE2MEM_Branch)
        if(EXE2MEM_predicted==1'b1&&EXE2MEM_ALUOut==1'b0)           //预测taken但实际没tabke
            PC<=EXE2MEM_NPC;
        else if(EXE2MEM_predicted==1'b0&&EXE2MEM_ALUOut==1'b1)      //预测not taken但实际taken
            PC<=EXE2MEM_BranchPC;
        else if(PCWrite==1'b0)
            PC<=PC;
        else if(rd_predicted)
            PC<=rd_predicted_PC;
        else
            PC<=PC+32'd4;
    else if(PCWrite==1'b0)
        PC<=PC;
    else if(rd_predicted)
        PC<=rd_predicted_PC;
    else
        PC<=PC+32'd4;
    //
    if(FlushIF)
    begin
        IF2ID_NPC<=32'd0;
        IF2ID_IR<=32'd0;
    end
    else if(IF2ID_Write)
    begin
        IF2ID_NPC<=PC+4;
        IF2ID_IR<=IMEM[PC];
    end
    
    else
    begin
        IF2ID_NPC<=IF2ID_NPC;
        IF2ID_IR<=IF2ID_IR;
    end
end
end

//ID
HAZARD_DETECTION U1(
.ID2EXE_MemRead(ID2EXE_MemRead),
.IF2ID_rs(IF2ID_rs),
.IF2ID_rt(IF2ID_rt),
.ID2EXE_rt(ID2EXE_rt),
.PCWrite(PCWrite),
.ID2EXE_Stall(ID2EXE_Stall),
.IF2ID_Write(IF2ID_Write)
);

always@(posedge clk,posedge rst)
if(rst)
begin
    ID2EXE_RegDst<=1'b0;
    ID2EXE_ALUSrc<=1'b0;
    ID2EXE_ALUOp<=2'b00;
    ID2EXE_MemRead<=1'b0;
    ID2EXE_MemWrite<=1'b0;
    ID2EXE_Branch<=1'b0;
    ID2EXE_RegWrite<=1'b0;
    ID2EXE_MemtoReg<=1'b0;
end
else if(ID2EXE_Stall||FlushID)
begin
    ID2EXE_RegDst<=1'b0;
    ID2EXE_ALUSrc<=1'b0;
    ID2EXE_ALUOp<=2'b00;
    ID2EXE_MemRead<=1'b0;
    ID2EXE_MemWrite<=1'b0;
    ID2EXE_Branch<=1'b0;
    ID2EXE_RegWrite<=1'b0;
    ID2EXE_MemtoReg<=1'b0;
end
else
case(IF2ID_IR[31:26])
6'b000000:begin
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b100100010;
end
6'b100011:begin
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b011110000;
end
6'b101011:begin
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b010001000;
end
6'b000100:begin
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b000000101;
end
default:
    {ID2EXE_RegDst,ID2EXE_ALUSrc,ID2EXE_MemtoReg,ID2EXE_RegWrite,ID2EXE_MemRead,
    ID2EXE_MemWrite,ID2EXE_Branch,ID2EXE_ALUOp}<=9'b000000000;
endcase

always@(posedge clk,posedge rst)
if(rst)
begin
    ID2EXE_rs<=5'd0;
    ID2EXE_rt<=5'd0;
    ID2EXE_rd<=5'd0;
    ID2EXE_Rs<=32'd0;
    ID2EXE_Rt<=32'd0;
    ID2EXE_Imm<=32'd0;
    ID2EXE_NPC<=32'd0;
end
else if(FlushID)
begin
    ID2EXE_rs<=5'd0;
    ID2EXE_rt<=5'd0;
    ID2EXE_rd<=5'd0;
    ID2EXE_Rs<=32'd0;
    ID2EXE_Rt<=32'd0;
    ID2EXE_Imm<=32'd0;
    ID2EXE_NPC<=32'd0;
end
else
begin
    ID2EXE_rs<=IF2ID_IR[25:21];
    ID2EXE_rt<=IF2ID_IR[20:16];
    ID2EXE_rd<=IF2ID_IR[15:11];
    ID2EXE_Rs<=RegFile[IF2ID_IR[25:21]];
    ID2EXE_Rt<=RegFile[IF2ID_IR[20:16]];
    ID2EXE_Imm<={{16{IF2ID_IR[15]}},IF2ID_IR[15:0]};
    ID2EXE_NPC<=IF2ID_NPC;
end

//EXE

FORWARDING U2(
.ID2EXE_rs(ID2EXE_rs),
.ID2EXE_rt(ID2EXE_rt),
.EXE2MEM_RegRd(EXE2MEM_RegRd),
.MEM2WB_RegRd(MEM2WB_RegRd),
.EXE2MEM_RegWrite(EXE2MEM_RegWrite),
.MEM2WB_RegWrite(MEM2WB_RegWrite),
.ForwardA(ForwardA),
.ForwardB(ForwardB)
);
//ALUSrcA三�?�一
mux3_1 U3(
.a(ID2EXE_Rs),
.b(EXE2MEM_ALUOut),
.c(MEM2WB_Data),
.select(ForwardA),
.out(ALUSrcA)
);
//ALUSrcB
mux3_1 U4(
.a(ID2EXE_Rt),
.b(EXE2MEM_ALUOut),
.c(MEM2WB_Data),
.select(ForwardB),
.out(ALUSrcB)
);

always@(posedge clk,posedge rst)
if(rst)
begin
    EXE2MEM_MemRead<=1'b0;
    EXE2MEM_MemWrite<=1'b0;
    EXE2MEM_Branch<=1'b0;
    EXE2MEM_MemtoReg<=1'b0;
    EXE2MEM_RegWrite<=1'b0;
end
else if(FlushEXE)
begin
    EXE2MEM_MemRead<=1'b0;
    EXE2MEM_MemWrite<=1'b0;
    EXE2MEM_Branch<=1'b0;
    EXE2MEM_MemtoReg<=1'b0;
    EXE2MEM_RegWrite<=1'b0;
end
else
begin
    EXE2MEM_MemRead<=ID2EXE_MemRead;
    EXE2MEM_MemWrite<=ID2EXE_MemWrite;
    EXE2MEM_Branch<=ID2EXE_Branch;
    EXE2MEM_MemtoReg<=ID2EXE_MemtoReg;
    EXE2MEM_RegWrite<=ID2EXE_RegWrite;
end

always@(posedge clk,posedge rst)
if(rst)
begin
    EXE2MEM_ALUOut<=32'd0;
    EXE2MEM_RegRd<=5'd0;
    EXE2MEM_Rt<=32'd0;
    EXE2MEM_BranchPC<=32'd0;
    EXE2MEM_NPC<=32'd0;
end
else
begin
    EXE2MEM_RegRd<=(ID2EXE_RegDst)?ID2EXE_rd:ID2EXE_rt;
    EXE2MEM_Rt<=ALUSrcB;               //ID2EXE_Rt or forwarded from EXE2MEM or forwarded from MEM2WB
    EXE2MEM_BranchPC<=ID2EXE_NPC+(ID2EXE_Imm<<2);
    EXE2MEM_NPC<=ID2EXE_NPC;
    case(ID2EXE_ALUOp)
        2'b00:EXE2MEM_ALUOut<=ALUSrcA+ID2EXE_Imm;          //lw or sw
        2'b01:EXE2MEM_ALUOut<=(ALUSrcA!=ALUSrcB)?1:0;
        2'b10:
        case (ID2EXE_Imm[5:0])
            6'b100000:EXE2MEM_ALUOut<=ALUSrcA+ALUSrcB;
            6'b100010:EXE2MEM_ALUOut<=ALUSrcA-ALUSrcB;
            6'b100100:EXE2MEM_ALUOut<=ALUSrcA&ALUSrcB;
            6'b100101:EXE2MEM_ALUOut<=ALUSrcA|ALUSrcB;
            6'b101010:EXE2MEM_ALUOut<=(ALUSrcA<ALUSrcB)?1:0;
        default: EXE2MEM_ALUOut<=EXE2MEM_ALUOut;
        endcase
        default:
            EXE2MEM_ALUOut<=EXE2MEM_ALUOut;
    endcase
end

//MEM
always@(posedge clk,posedge rst)
if(rst)
begin
    MEM2WB_RegWrite<=1'b0;
    MEM2WB_MemtoReg<=1'b0;
end
else
begin
    MEM2WB_RegWrite<=EXE2MEM_RegWrite;
    MEM2WB_MemtoReg<=EXE2MEM_MemtoReg;
end

always@(posedge clk,posedge rst)
if(rst)
begin
    MEM2WB_LDM<=32'd0;
    MEM2WB_ALUOut<=32'd0;
    MEM2WB_RegRd<=5'd0;
end
else
begin
    MEM2WB_ALUOut<=EXE2MEM_ALUOut;
    MEM2WB_RegRd<=EXE2MEM_RegRd;
    if(EXE2MEM_MemRead)
        MEM2WB_LDM<=DMEM[EXE2MEM_ALUOut];
    else if(EXE2MEM_MemWrite)
        DMEM[EXE2MEM_ALUOut]<=EXE2MEM_Rt;
end

//WB
always@(negedge clk,posedge rst)
if(rst)
    ;
else if(MEM2WB_RegWrite)
    if(MEM2WB_MemtoReg)
        RegFile[MEM2WB_RegRd]<=MEM2WB_LDM;
    else
        RegFile[MEM2WB_RegRd]<=MEM2WB_ALUOut;
        
endmodule
FPGA硅农
关注
专栏目录
分支预测的地址跳转
major的博客
05-24 1065
因此，到目前为止，对于分支指令的目标地址的预测，有下面的三种方法。这些方式都是在取指阶段，利用pc值来进行；(1)使用 BTB 对直接跳转(PC-relative)类型的分支指令和 CALL 指令进行预测；(2)使用RAS对Return指令进行预测;(3)使用 Target Cache 对其他类型的分支指令进行预测。尤其是对于BTB和RAS, 几乎是现代的超标量处理器必须要使用的。
简易 MIPS 结构 Branch部分
11-21
用VHDL写的简易MIPS结构，该文件为Branch部分代码。
分支预测技术
最新发布
qq_65052774的博客
08-01 776
分支预测是用来的一种技术。在现代计算机架构中，为了提高执行速度，处理器常常采用流水线技术来同时执行多条指令。当程序中出现条件分支（如 if-else 语句或循环）时，处理器必须等待分支条件的结果来确定下一条执行的指令路径。分支预测技术的引入是为了减少这种等待所造成的时间浪费，从而提高处理器的性能。
Branch Target Buffers
cicuinie0996的博客
07-28 817
http://en.wikipedia.org/wiki/Branch_target_predictor 简要原理 http://www-ee.eng.hawaii.edu/~tep/EE461/Notes/ILP/buffer.html http://web.cs.dal.ca...
计算机体系结构第五次实验——Branch-Target Buffers（BTB）
weixin_51529433的博客
07-30 2715
本次实验的主要目的是加深对Branch-TargetBuffers的理解。掌握使用Branch-TargetBuffers减少或增加分支带来的延迟的情况。
计算机体系结构实验——Branch-Target Buffers
weixin_63614711的博客
12-22 911
计算机体系结构实验——BTB
体系结构实验（5）——分支预测
zyw2002的博客
10-15 3339
从第二轮循环开始，每次在分支跳转的过程中都可以从BTB表中找到PC值，因此不会有额外的分支跳转延时。循环的条件是R4不等于0。因此 在BTB表中未找到该PC值对应的预测分支目标地址，但是接下来第一条转移成功的指令，因此需要将该指令以及目标地址送入缓冲器中。总共99次的循环中，有三次预测失败（第一次和第二次以及最后一次），其余的均预测成功。在接下来的循环中，每次都预测成功，History和Prediction的表项保持不变。的值不为0，所以是转移成功指令，BTB中的该表项不会被移除，直到循环的最后一次。
动态分支预测MIPS.rar
09-13
动态分支预测器（BTB，Branch Target Buffer）是一种常用的解决方案，它根据历史分支信息预测未来的分支行为。BTB会存储过去的分支地址和对应的分支目标地址，以及分支是否被预测为取反的信息。通过比较实际分支结果...
计组实验4 控制冒险与分支预测
AKGWSB 's blog
12-19 4931
目录前言实验内容背景知识分支预测技术⭐阻塞周期计算方法不开启 BTB开启 BTBpart 1 矩阵乘法与优化未开启 BTB 的分析开启 BTB 的分析part 2 设计代码使 BTB 无效part 3 循环展开优化矩阵乘法未开启 BTB开启 BTB结束语结论 前言 上一篇博客：计组实验3 mips冒险之流水线冒险 摸了半个月了。。。咕咕咕 今天来写计组实验 4 这个实验非常简单，就是有点难。 这个实验比较容易算错，或者是被模拟器出人意料的结果搞的神神叨叨的，所以今天来记录并且详细分析该实验。 注：请务必阅
分支预测器（Branch Predictor） 汇总介绍
weixin_30819085的博客
04-03 3787
当包含流水线技术的处理器处理分支指令时就会遇到一个问题，根据判定条件的真/假的不同，有可能会产生转跳，而这会打断流水线中指令的处理，因为处理器无法确定该指令的下一条指令，直到分支执行完毕。流水线越长，处理器等待的时间便越长，因为它必须等待分支指令处理完毕，才能确定下一条进入流水线的指令。 分支预测技术便是为解决这一问题而出现的。 分支预测技术包含编译时进行的静态分支预测和硬...
实验四：处理器结构实验二1
08-08
【实验四：处理器结构实验二1】主要探讨了处理器结构中的控制冒险、分支预测以及BTB（Branch Target Buffer）在优化程序执行效率方面的作用。实验旨在让学生深入理解这些概念，并通过实际操作提升对WinMIPS64处理器...
论BTB和I-TLB的作用
07-03
论BTB和I-TLB的作用 BTB(Branch Target Buffer )，即分支目标缓冲。在Nehalem的指令拾取单元中包含有相关指令指针（relative instruction point，RIP），每个线程状态各有一个。 而I-TLB，Instruction Translation lookaside buffer,是TLB,即旁路转换缓冲，或称为页表缓冲的其中一组。TLB是在处理器的总线接口单元的硬件缓存，用于存储最近使用的页表项的副本，这加快从虚拟地址到物理地址的转换。
uboot研读笔记 | 14 - uboot启动流程分析（2016.03版本）
Mculover666的博客（嵌入式）
03-11 1601
一、第一行代码 要分析uboot启动流程，先得找到uboot启动的第一行代码，编译uboot，查看u-boot.map文件，找到Linker script and memory map这一节： .text 0x0000000087800000 0x3e734 *(.__image_copy_start) .__image_copy_start 0x0000000087800000 0x0 arch/arm/lib/built-in.
（转）【CPU微架构设计】利用Verilog设计基于饱和计数器和BTB的分支预测器
qq_34010867的博客
11-26 4071
在基于流水线（pipeline）的微处理器中，分支预测单元（Branch Predictor Unit）是一个重要的功能部件，它负责收集和分析分支/跳转指令的执行结果，当处理后续分支/跳转指令时，BPU将根据已有的统计结果和当前分支跳转指令的参数，预测其执行结果，进而为流水线取指提供决策依据，从而提高流水线效率。 　　本文将针对分支预测单元的设计思路进行讨论。在进行设计前，首先需要说明使用分支预...
CPU设计-分支预测
yueqiu693的博客
07-17 3513
CPU设计-分支预测
【分支预测】（二）目标地址预测
Alchemist2002的博客
03-21 1527
Target address 分为两种：直接跳转 PC-relative和间接跳转absolute 直接跳转偏移值offset以立即数的形式固定在指令里 间接跳转目标来自通用寄存器，相比于其他间接跳转的分支指令，更推荐编译使用call/return 1. 直接跳转类型的分支预测 1.1 BTB 不跳转：PC+4（sizeof(fetch group)） 跳转：PC+sign_extend(offset) 多个PC共用一个空间存储目标地址。使用一个称为BTB（Branch Target Buffe.
计算机体系结构——分支预测
TL2363023951的博客
04-09 2089
分支预测解决流水线冲突中的控制冒险。在指令集中，分支指令包括条件指令和非条件指令。对无条件指令来说，无需进行条件判断，就可以获得跳转后的地址；但是对条件跳转指令，无论是条件直接跳转还是条件间接跳转指令（RISC-V 无此类指令），都需要在执行阶段才可以确定是否跳转，这样会影响取值阶段的效率。
MIPS指令集：运算指令、访存指令、分支和跳转、协处理器0指令
海棠花的博客
02-22 3万+
计算机指令就是指挥机器工作的指示和命令，程序就是一系列按一定顺序排列的指令，执行程序的过程就是计算机的工作过程。通常一条指令包括两方面的内容： [1]操作码和操作数，操作码决定要完成的操作，操作数指参加运算的数据及其所在的单元地址。在第2章时我们介绍了MIPS所有指令都是32位的，操作码占用高6位（bit31-bit26）表示，低26位按格式划分为R型、I型和J型。本章将按mip...
MIPS中的跳转/分支指令
热门推荐
曾梦想仗剑走天涯
05-11 9万+
本文节选自《See MIPS run2rd》/《MIPS体系结构透视》中的部分章节，结合个人理解，对部分译文有所改动。 1.5.2 编址及内存访问 1.5.4 程序员可见的流水线效果 8.7.8 跳转, 分支和子程序调用指令
实验二 MIPS指令调度和延迟分支 互锁机制工作原理
06-10
在MIPS指令调度和延迟分支中，互锁机制的工作原理是通过硬件实现的。其基本思想是在发现数据或控制相关时，通过暂停执行指令的方式来避免相关问题的出现。 具体来说，互锁机制包括以下几个步骤： 1. 检测相关：当一条指令需要使用到之前指令的结果或分支结果时，就会触发相关检测。这个过程通常由硬件实现，可以通过比较指令中的寄存器编号和功能码等来判断是否存在相关。 2. 暂停执行：如果发现相关，就会暂停当前指令的执行，等待前面指令的结果。具体来说，对于名相关，后续指令会等待前面指令的结果写入寄存器；对于数据相关，后续指令会等待前面指令的分支结果。 3. 保持互锁：为了避免相关问题的出现，暂停执行的指令会保持互锁状态，直到前面指令的结果计算完成或分支结果确定后才能继续执行。这个过程通常由硬件实现，可以通过设置互锁标志或清除互锁标志来实现。 4. 解除互锁：当前面指令的结果计算完成或分支结果确定后，就会解除互锁，允许后续指令继续执行。这个过程通常由硬件实现，可以通过清除互锁标志或改变指令执行状态来实现。 总之，互锁机制通过暂停执行指令的方式来避免相关问题的出现，从而保证指令的正确执行顺序。这个机制通常由硬件实现，可以大大提高指令执行的效率和正确性。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FPGA硅农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值