FPGA 与数字 IC 设计 / 系统课时

检查 FIFO 同时读写的边界情况

检查 FIFO 同时读写的边界情况

同步 FIFO 在正常入队、出队时可能工作正确,却在空队列读取、满队列写入或同一周期同时读写时出现计数错误。本课使用一个深度为 4 的同步 FIFO,明确边界周期的接收规则,编写可运行的 SystemVerilog 测试,并验证数据顺序、计数和满空标志是否一致。

学习目标

  • 区分读写请求与实际成功的入队、出队操作。
  • 理解 FIFO 在空、满及同时读写时的指针和计数变化。
  • 使用自检测试覆盖关键边界,定位丢数据、重复读取和计数溢出。

先确定读写成功的判定规则

本例采用单时钟 FIFO,深度 DEPTH=4,数据宽度 WIDTH=8,允许在非空非满时同时读写。输入 wr_en、rd_en 表示请求,输出 full、empty 由当前已存数据数量决定。

采用保守边界策略:满时拒绝写入,即使同时请求读取;空时拒绝读取,即使同时请求写入。 这种实现简单,但不是支持满状态零气泡置换的高吞吐实现。

实际操作必须由当前状态决定:

systemverilog
assign wr_fire = wr_en && !full;
assign rd_fire = rd_en && !empty;

以上是片段示例,依赖后文完整模块中的 wr_en、rd_en、full、empty 和 wr_fire、rd_fire 声明。wr_fire、rd_fire 才是更新指针和计数的依据,不能直接使用请求信号。

原有数量 wr_en rd_en 成功操作 新数量
0 1 0 入队 1
0 0 1 无 0
0 1 1 仅入队 1
2 1 1 入队和出队 2
4 1 0 无 4
4 1 1 仅出队 3

表中的数量是时钟上升沿之后的结果。对于同一周期读写均成功的情况,读指针和写指针各前进一次,数量不变;不能因为计数不变就认为没有发生传输。

同时读写为什么容易出错

FIFO 至少包含存储数组、写指针、读指针和计数器四个相关对象。两个请求可能同时改变不同对象,因此要把接收条件和状态更新放在同一个时钟边界理解。

同步FIFO同时读写和边界计数变化示意图

一个常见错误是对 wr_en 和 rd_en 分别编写计数赋值。若在同一 always_ff 中连续执行 count <= count + 1 和 count <= count - 1,两条非阻塞赋值都基于旧值计算,后面的赋值覆盖前面的调度结果,导致同时读写后计数错误。

正确方法是按两个成功信号的组合只更新一次计数,同时独立控制两个指针。满空标志由更新后的计数在下一周期组合得到。

实现可验证的四槽 FIFO

下面是完整的单时钟、首字直通可见(FWFT 风格)的教学模块。data_out 组合读取当前队首,仅当 empty=0 时有效;成功读取的字节在读取上升沿之前可见。该写法适合小容量寄存器数组演示,不保证综合为特定 FPGA 块 RAM 的同步读端口。

systemverilog
module sync_fifo #(
    parameter int WIDTH = 8,
    parameter int DEPTH = 4
) (
    input  logic clk,
    input  logic rst_n,
    input  logic wr_en,
    input  logic rd_en,
    input  logic [WIDTH-1:0] data_in,
    output logic [WIDTH-1:0] data_out,
    output logic full,
    output logic empty,
    output logic [$clog2(DEPTH+1)-1:0] count
);
    localparam int PTR_W = $clog2(DEPTH);
    logic [WIDTH-1:0] mem [0:DEPTH-1];
    logic [PTR_W-1:0] wr_ptr, rd_ptr;
    logic wr_fire, rd_fire;

    assign full = (count == DEPTH);
    assign empty = (count == 0);
    assign wr_fire = wr_en && !full;
    assign rd_fire = rd_en && !empty;
    assign data_out = mem[rd_ptr];

    always_ff @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            wr_ptr <= '0;
            rd_ptr <= '0;
            count <= '0;
        end else begin
            if (wr_fire) begin
                mem[wr_ptr] <= data_in;
                wr_ptr <= (wr_ptr == DEPTH-1) ? '0 : wr_ptr + 1'b1;
            end
            if (rd_fire)
                rd_ptr <= (rd_ptr == DEPTH-1) ? '0 : rd_ptr + 1'b1;

            // 同时成功时数量不变,但两个指针仍须移动。
            case ({wr_fire, rd_fire})
                2'b10: count <= count + 1'b1;
                2'b01: count <= count - 1'b1;
                default: count <= count;
            endcase
        end
    end
endmodule

DEPTH=4 时计数需要 3 位,可以表示 0~4;指针只需要 2 位,范围为 0~3。代码使用显式回绕判断,避免把任意深度的指针回绕错误地等同于二进制自然溢出。此示例要求 DEPTH>=2,并默认 DEPTH 是正整数。

存储数组没有复位,复位只清空指针和计数;因此空状态下的 data_out 可以是未知或旧数据,不能被接收端当作有效数据使用。

编写边界自动检查

保存前面的模块为 sync_fifo.sv,再将下面测试保存为 tb_fifo.sv。测试在时钟下降沿设置请求,在下一上升沿之前核对旧队首数据,并在上升沿之后核对计数、满空标志。这样能明确区分采样前状态与更新后状态。

systemverilog
module tb_fifo;
    logic clk = 0;
    logic rst_n = 0;
    logic wr_en = 0, rd_en = 0;
    logic [7:0] data_in = 0;
    logic [7:0] data_out;
    logic full, empty;
    logic [2:0] count;
    byte unsigned model[$];
    int cycles = 0;

    always #5 clk = ~clk;

    sync_fifo dut (
        .clk(clk), .rst_n(rst_n),
        .wr_en(wr_en), .rd_en(rd_en),
        .data_in(data_in), .data_out(data_out),
        .full(full), .empty(empty), .count(count)
    );

    task automatic step(input bit w, input bit r, input byte unsigned d);
        bit write_ok, read_ok;
        byte unsigned expected;
        @(negedge clk);
        wr_en = w;
        rd_en = r;
        data_in = d;
        #1;
        // 请求能否成功,必须由本周期时钟沿之前的状态决定。
        write_ok = w && (model.size() < 4);
        read_ok = r && (model.size() > 0);
        if (count != model.size() || full != (model.size() == 4)
            || empty != (model.size() == 0))
            $fatal(1, "pre-edge state mismatch");
        if (read_ok) begin
            expected = model[0];
            if (data_out !== expected)
                $fatal(1, "data mismatch: got=%h expected=%h", data_out, expected);
        end
        @(posedge clk);
        // 参考队列先移除旧队首,再加入本周期成功写入的数据。
        if (read_ok) expected = model.pop_front();
        if (write_ok) model.push_back(d);
        #1;
        if (count != model.size() || full != (model.size() == 4)
            || empty != (model.size() == 0))
            $fatal(1, "post-edge state mismatch");
        cycles++;
    endtask

    initial begin
        repeat (2) @(negedge clk);
        rst_n = 1;
        step(0, 1, 0);       // 空读被拒绝
        step(1, 1, 8'h11);   // 空时同时请求,仅写成功
        step(1, 1, 8'h22);   // 普通同时读写
        step(1, 0, 8'h33);
        step(1, 0, 8'h44);
        step(1, 0, 8'h55);   // 达到满状态
        step(1, 0, 8'h66);   // 满写被拒绝
        step(1, 1, 8'h77);   // 满时同时请求,仅读成功
        step(0, 1, 0);
        step(0, 1, 0);
        step(0, 1, 0);
        step(0, 1, 0);       // 空读再次被拒绝
        $display("PASS cycles=%0d count=%0d", cycles, count);
        $finish;
    end
endmodule

可以使用支持 SystemVerilog 队列的仿真器运行。例如在 Icarus Verilog 的兼容版本中执行:

bash
iverilog -g2012 -s tb_fifo -o fifo_sim sync_fifo.sv tb_fifo.sv
vvp fifo_sim

预期输出(仿真器可能额外输出结束位置提示):

text
PASS cycles=12 count=0

测试通过表示这 12 组固定刺激下,队列参考模型与被测 FIFO 的计数、满空标志以及有效读出的数据一致。若出现 $fatal,退出状态为失败,不应把仿真结束误认为通过。

如何扩大覆盖并判断边界是否正确

固定测试后,再补充随机组合,至少覆盖 wr_en、rd_en 的 00、01、10、11 四种取值,并覆盖 count=0、中间值、count=DEPTH 三类状态。每次操作均使用参考队列计算成功条件,不应直接根据请求修改期望队列。

建议把以下条件作为检查清单:

检查项 必须满足的结果
空读 rd_fire=0,读指针和计数不变
满写 wr_fire=0,写指针和计数不变
普通同时读写 两指针前进,计数不变,读出旧队首
空时同时请求 只写入,计数从 0 变 1
满时同时请求 只读出,计数从 4 变 3
指针回绕 到达槽位 3 后返回槽位 0,数据顺序正确
复位 count=0、empty=1、full=0

工程中还应对 count 始终位于 0~DEPTH 的范围、满空互斥、读写指针仅在实际成功时移动建立断言;随机测试则应多次跨越满空边界和指针回绕点。以上示例是单时钟 FIFO,不适用于直接验证跨时钟异步 FIFO 的指针同步与亚稳态处理。

当同时读写后的计数正确、数据顺序正确,且被拒绝的请求完全不会改变队列状态时,才能认为这些同步 FIFO 边界行为得到有效验证。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

检查 FIFO 同时读写的边界情况

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通