计算机体系结构--指令Cache设计verilog实现

前段时间一直在做MIPS CPU的设计，并且同步学习了一些计算机体系结构的相关知识，五级流水线单周期CPU设计已经完善了，本文主要记录一下指令Cache的设计及实现。

一、Cache设计思路

很多文章和书籍都详细得介绍了Cache的内容，具体内容可以自行查阅，本人参考的书籍是姚永斌老师著的《超标量处理器设计》以及网上一些优秀的博客。

指令Cache (ICache) 的模块框架如下：（一般L1-Cache是集成在CPU内的，这里框图描述将两者分开了）

端口信号比较清晰，与CPU的接口有：来自CPU的请求信号和地址信号，返回给CPU的有效与数据信号。而访问指令存储器的接口信号也一样，对称设计。

这里唯一的区别是访存时Cache一次读取4个字，也就是128bit。但是Cache返回给CPU是一个字（一条指令）也就是32bit。所以mem_req_data与cpu_req_data数据位宽是不一样的。这样的差别主要与Cacheline的设计相关，一次从内存取多少数据完全是根据具体需求来。

I_Cache内部的逻辑实现主要由状态机来进行控制。我们知道Cache得到一个地址先要查询地址中对应的Index，寻址到对应的Cacheline，判断有效位V是否为1，如果为0那么代表这条Cacheline还没被主存映射，如果为1那么再对比Tag位，如果相等就表示命中hit，就可以根据地址中的offset位来寻址Cacheline中具体的数据位置，返回需要的数据给CPU。指令Cache一般是不往里面写数据的，但是必须要注意到Cacheline中有一个脏位Dirty，是在写入策略中起到作用的。程序中的store指令需要往主存中写入数据，如果直接写到主存中那么速度很慢，CPU没法等，就可以先写到Cacheline中，并把Dirty位置1，如果下次需要替换这条Cacheline，那么再把这条Cacheline的内容写到主存中，并把dirty位清0。相当于缓存了需要store的数据。这种方式称之为写回策略Write Back。直接写到主存中的写入策略称之为写通Write Through。

本文的I_Cache是基于2路组相连 2-way set-associated映射方式的Cache，主存设计为128KB，Cache一共有16组。因此PC地址划分为：

当然上面只介绍了命中Cache的行为，当Cache丢失miss怎么办呢？这时候就需要用地址访问主存，并把对应的数据加载到Cache中，替换策略可以分为写替换策略和读替换策略，具体的实现方法也很多，比如LRU近期最少使用算法，FIFO替换，或者随机替换算法。本文使用了一个简单的替换方法。打算后续在实现数据Cache时学习LRU算法的设计。

从上面的分析可以以及模块接口信号的描述可以设计状态机，具体实现如下：

状态机分为四个状态：IDLE+CompareTag+WriteBack+Allocate 分别对应上文对应的Cache行为，这里就不阐述了。

RTL代码如下：

//2-way set associate cache
//addressing 2*index+0/1
//capacity 4Kb
`include "macro.v"
module I_Cache(
    input             wire             clk,
    input             wire             rst,
    //to mem
    output             reg [`InstAddrBus]        mem_req_addr,
    output             reg [127:0]                mem_wr_data,
    output             reg                     mem_req_valid,
    output             reg                     mem_req_wr,            //read only
    input             wire [127:0]            mem_req_data,
    input             wire                     mem_req_ready,
    //to CPU
    input             wire [`InstAddrBus]        cpu_req_addr,
    input             wire                     cpu_req_valid,
    input             wire                     cpu_req_wr,
    output             reg [`RegBus]            cpu_req_data,
    output             reg                     cpu_req_ready             
    );


localparam             IDLE=4'b0001,CompareTag=4'b0010,WriteBack=4'b0100,Allocate=4'b1000;
localparam            V=141,D=140,U=139,TagMSB=138,TagLSB=128,DataMSB=127,DataLSB=0;
wire                 hit,way1hit,way2hit;
wire                 CachelineDirty;
reg                 way;                                                //cache miss,evict cacheline
wire         [3:0]    cpu_req_index;
wire         [23:0]    cpu_req_tag;
wire         [1:0]    cpu_req_offset;
integer             i;
wire                 mem_ready_valid;
reg     [141:0] cache_data [31:0];
reg     [3:0]    state,next_state;


assign way1hit = cache_data[2*cpu_req_index][V]==1'b1 && cache_data[2*cpu_req_index][TagMSB:TagLSB]==cpu_req_tag;
assign way2hit = cache_data[2*cpu_req_index+1][V]==1'b1 && cache_data[2*cpu_req_index][TagMSB:TagLSB]==cpu_req_tag;

//Byte addressing
assign cpu_req_index = cpu_req_addr[7:4];
assign cpu_req_tag = cpu_req_addr[31:8];
assign cpu_req_offset = cpu_req_addr[3:2];

assign mem_ready_valid = mem_req_valid & mem_req_ready;

assign hit = way1hit | way2hit;
assign CachelineDirty = cache_data[2*cpu_req_index+way][V:D]==2'b11;

//FSM
always @(posedge clk) begin
    if (rst) begin
        // reset
        state <= IDLE;
    end
    else begin
        state <= next_state;
    end
end

always @(*) begin
    case(state)
        IDLE: next_state = cpu_req_valid ? CompareTag : IDLE;
        CompareTag:begin
            if (cpu_req_valid) begin
                if (hit) begin
                    next_state = CompareTag;
                end
                else if (CachelineDirty) begin
                    next_state = WriteBack;
                end
                else begin
                    next_state = Allocate;
                end
            end
            else begin
                next_state = IDLE;
            end
        end 
        WriteBack: next_state = mem_req_ready ? Allocate : WriteBack;
        Allocate: next_state = mem_req_ready ? CompareTag : Allocate;
        default:begin
            next_state = IDLE;
        end
    endcase
end

//way
always @(*) begin
    if (!hit) begin
        case({cache_data[2*cpu_req_index][V],cache_data[2*cpu_req_index+1][V]})
            2'b00:way=1'b0;
            2'b01:way=1'b0;
            2'b10:way=1'b1;
            2'b11:way=1'b0;
            default:way=1'b0;
        endcase
    end
end

//cpu_req_data
always @(*) begin
    if (rst) begin
        // reset
        cpu_req_data <= 'd0;
    end
    else if (state==CompareTag && hit) begin
        cpu_req_data <= way1hit ? cache_data[2*cpu_req_index][(3-cpu_req_offset)<<5+:31] : 
                                    cache_data[2*cpu_req_index+1][(3-cpu_req_offset)<<5+:31];
    end
    else begin
        cpu_req_data <= cpu_req_data;
    end
end

//cache_line data update
always @(posedge clk) begin
    if (rst) begin
        // reset
        for(i=0;i<32;i=i+1)begin
            cache_data[i] <= 'd0;
        end
    end
    else if (state==WriteBack && mem_ready_valid==1'b1) begin
        cache_data[2*cpu_req_index+way][D] <= 1'b0;
    end
    else if (state==CompareTag && CachelineDirty==1'b1) begin
        cache_data[2*cpu_req_index+way][D] <= 1'b1;
    end
    else if (state==Allocate && mem_ready_valid==1'b1) begin
        cache_data[2*cpu_req_index+way][V] <= 1'b1;
        cache_data[2*cpu_req_index+way][DataMSB:DataLSB] <= mem_req_data;
        cache_data[2*cpu_req_index+way][TagMSB:TagLSB] <= cpu_req_addr[cpu_req_tag];
    end
end

//cpu_req_ready
always @(*) begin
    if (state==CompareTag && hit==1'b1) begin
        cpu_req_ready <= 1'b1;
    end
    else begin
        cpu_req_ready <= 1'b0;
    end
end

//mem_req_addr
always @(*) begin
    if (rst) begin
        // reset
        mem_req_addr <= 'd0;
    end
    else if (state==WriteBack || state==Allocate) begin
        mem_req_addr <= cpu_req_addr;
    end
end

//mem_req_valid
always @(posedge clk) begin
    if (rst) begin
        // reset
        mem_req_valid <= 1'b0;
    end
    else if (state==CompareTag && hit==1'b0) begin 
        mem_req_valid <= 1'b1;
    end
    else if (state==WriteBack && mem_req_ready==1'b1) begin
        mem_req_valid <= 1'b0;
    end
    else if (state==Allocate && mem_req_ready==1'b1) begin
        mem_req_valid <= 1'b0;
    end
end

//mem_wr_data
always @(posedge clk) begin
    if (rst) begin
        // reset
        mem_wr_data <= 'd0;
    end
    else if (state==WriteBack) begin
        mem_wr_data <= cache_data[2*cpu_req_index+way][DataMSB:DataLSB];
    end
end

endmodule

二、仿真验证

本人在进行设计与验证时也遇到了不少麻烦，主要是要与MIPS-CPU和主存协同设计，并不是只是设计个Cache和主存进行仿真就ok了，所以还涉及CPU中Program Couter模块部分的指令跳转问题，对于流控也进行了一些修改，可能代码也存在一些遗漏与不足，各位在阅读本文时可以根据思路自行修改与设计。

I_Cache模块的信号如上图所示，可以看到状态正确的实现跳转，state信号=8代表着进入Allocate阶段，=2表示进入了CompareTag阶段。同时可以看到Cache hit与miss情况。

上图展示了CPU中译码阶段的执行情况，可以看到PC按顺序增加，并且在碰到跳转指令时正确的执行了跳转。pc_i信号中间为0的部分就是表示正在经历Cache读取主存进入了Allocate阶段，因此存在一些空指令，还存在可以优化的空间。

实际上如果能FPGA上板验证的话能更好的感受Cache的加速效果，毕竟modelsim仿真没法涉及真实的访存时间。 因此还需要更深入的学习与探讨！