基于System Verilog的同步FIFO实现(一)_system verilog fifo

FIFO，全称First In First Out，它是数字电路设计中一个重要的基本单元，它分为同步FIFO和异步FIFO，所谓同步FIFO，是指读写都是在同一个时钟的驱动下进行的，而异步FIFO读写操作的时钟是分离的，本文主要讲述同步FIFO的实现。

如图，是同步FIFO的一个示意图，它由clk,rst,wr_en,rd_en,full,empty,rdata,wdata等信号构成，其中，full,empty用于指示fifo的状态(空或满)，wr_en,rd_en分别为写使能和读使能信号，在FIFO的设计中，难点莫过于full,empty信号的生成。
在FIFO的设计中，一般会设计两个指针，一个读指针，一个写指针，他们分别指向下一个要读(写)的地址，因此，我们可以通过比较读写指针的值，来进行FIFO空满的判断，这会稍微复杂一些，将在下一篇博客中详细介绍，本文采用的是另一种比较简单的方法:在FIFO内设置一个计数器，用于记录FIFO中当前的数据个数，这样当FIFO数据个数为0时，empty信号有效，当FIFO数据个数为FIFO_DEPTH-1时，full信号有效，表示FIFO已满。
RTL代码实现如下:

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2022/02/22 00:05:11
// Design Name: 
// Module Name: sync_fifo
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module sync_fifo
#(parameter DATA_WIDTH = 32,
  parameter FIFO_DEPTH = 32)
(
input logic clk,
input logic rst,
input logic wr_en,
input logic [DATA_WIDTH-1:0] wdata,
input logic rd_en,
output logic [DATA_WIDTH-1:0] rdata,
output logic full,
output logic empty
    );
logic [$clog2(FIFO_DEPTH):0] data_count;              //当前FIFO中的数据个数
logic [$clog2(FIFO_DEPTH)-1:0] wr_ptr;                  //指向下一个要写的地址
logic [$clog2(FIFO_DEPTH)-1:0] rd_ptr;                  //指向下一个要读的地址
//
logic [DATA_WIDTH-1:0] FIFO [0:FIFO_DEPTH-1];
//data_count
always_ff@(posedge clk,posedge rst)
if(rst)
    data_count<=0;
else 
begin
    case({wr_en,rd_en})
        2'b00:data_count<=data_count;
        2'b11:data_count<=data_count;
        2'b01:data_count<=data_count-1;
        2'b10:data_count<=data_count+1;            //所有情况都已经列出，无需default
    endcase
end
//wr_ptr
always_ff@(posedge clk,posedge rst)
if(rst)
    wr_ptr<=0;                                    //复位时写指针为0
else if(wr_en&&~full)                             //写使能信号有效且fifo未满
if(wr_ptr==FIFO_DEPTH-1)
    wr_ptr<=0;
else
    wr_ptr<=wr_ptr+1;
//rd_ptr
always_ff@(posedge clk,posedge rst)
if(rst)
    rd_ptr<=0;
else if(rd_en&&~empty)                            //写使能信号有效且FIFO非空
if(rd_ptr==FIFO_DEPTH-1)
    rd_ptr<=0;
else
    rd_ptr<=rd_ptr+1;
//flag
assign full=(data_count==FIFO_DEPTH)?1'b1:1'b0;
assign empty=(data_count==0)?1'b1:1'b0;
//write
always_ff@(posedge clk)
if(wr_en&&~full)
    FIFO[wr_ptr]<=wdata;
//read
always_ff@(posedge clk,posedge rst)          //rd_en拉高后的下一个周期读出
if(rst)
    rdata<=0;
else if(rd_en&&~empty)
    rdata<=FIFO[rd_ptr];
endmodule



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

这里$clog2是system verilog的系统函数，表示以2为底取对数的意思。
下面是testbench

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2022/02/22 00:27:44
// Design Name: 
// Module Name: test
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module test;
parameter DATA_WIDTH = 32;
parameter FIFO_DEPTH = 32;
logic wr_en_r;
logic rd_en_r;
logic clk;
logic rst;
logic wr_en;
logic rd_en;
logic [DATA_WIDTH-1:0] wdata;
logic [DATA_WIDTH-1:0] rdata;
logic empty;
logic full;
logic error;
logic [DATA_WIDTH-1:0] ref_data;
logic data_valid;
//data_valid
always@(posedge clk,posedge rst)
if(rst)
   data_valid<=0;
else
   data_valid<=(rd_en&&~empty);
//ref_data
always@(posedge clk,posedge rst)
if(rst)
   ref_data<=0;
else if(data_valid)
   ref_data<=ref_data+1;
//error
assign error=(data_valid&&(ref_data!=rdata))?1'b1:1'b0;
//wr_en,rd_en
assign wr_en=(~full)?wr_en_r:1'b0;
assign rd_en=(~empty)?rd_en_r:1'b0;
//clk
initial begin
    clk=0;
    forever begin
        #5 clk=~clk;
    end
end
//rst
initial
begin
    rst=1;
    #20
    rst=0;
end
//wdata
always_ff@(posedge clk,posedge rst)
if(rst)
    wdata<=0;
else if(wr_en&&~full)                //每写入一个数据，加1
    wdata<=wdata+1;
//wr_en
always_ff@(posedge clk,posedge rst)
if(rst)
    wr_en_r<=0;
else if($random%100<60)               //有60%的几率写数据,衡量数据写入速率
    wr_en_r<=1'b1;
else
    wr_en_r<=1'b0;
//rd_en
always_ff@(posedge clk,posedge rst)
if(rst)
    rd_en_r<=0;
else if($random%100<40)                //有40%的几率读数据，衡量数据读出速率
    rd_en_r<=1'b1;
else 
    rd_en_r<=1'b0;
//inst
sync_fifo
#(
.DATA_WIDTH(32),
.FIFO_DEPTH(32)
)
U
(.*);
// input logic clk,
// input logic rst,
// input logic wr_en,
// input logic [DATA_WIDTH-1:0] wdata,
// input logic rd_en,
// output logic [DATA_WIDTH-1:0] rdata,
// output logic full,
// empty
endmodule



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

为了更加全面的进行仿真，在本测试平台中，写入数据wdata是顺序增加的，而wr_en和rd_en信号则是随机生成的，如下图所示

wr_en_r信号以60%的概率拉高，rd_en_r以40%的概率拉高，当然，只有当FIFO未满或者非空时，_en_r信号才会赋值给_en信号，在这个例子中，60%和40%分别可以视作FIFO的数据写入速率和FIFO的数据读出速率，读者可以修改这两个参数，观察波形的变换情况。
附一张仿真波形图：