深入理解FIFO以及同步FIFO和异步FIFO的verilog实现代码

发表于 更新于 分类于 ，
本文字数： 11k 阅读时长 ≈ 10 分钟

本文转载自 https://www.cnblogs.com/xuqing125/p/8337586.html

1. FIFO概述

FIFO即First In First Out，是一种先进先出数据存储、缓冲器，我们知道一般的存储器是用外部的读写地址来进行读写，而FIFO这种存储器的结构并不需要外部的读写地址而是通过自动的加一操作来控制读写，这也就决定了FIFO只能顺序的读写数据。下面我们就介绍一下同步FIFO和异步FIFO。

FIFO分类

同步FIFO，读和写是同一个时钟。它的作用一般是做交互数据的一个缓冲，也就是说它的主要作用就是一个buffer。
异步FIFO，读和写是不同的时钟，它有两个主要的作用，一个是实现数据在不同时钟域进行传递，另一个作用就是实现不同数据宽度的数据接口。

FIFO的主要参数

同步FIFO和异步FIFO略有不同，下面的参数适用于两者。

  • 宽度，用参数FIFO_data_size表示，也就是FIFO存储的数据宽度；
  • 深度，用参数FIFO_addr_size表示，也就是地址的大小，也就是说能存储多少个数据；
  • 满标志，full，当FIFO中的数据满了以后将不再能进行数据的写入;
  • 空标志，empty，当FIFO为空的时候将不能进行数据的读出；
  • 写地址，w_addr，由自动加一生成，将数据写入该地址；
  • 读地址，r_addr，由自动加一生成，将该地址上的数据读出；

同步FIFO和异步FIFO的最主要的不同就体现在空满标志产生的方式上，由此引出两者一些不同的参数。
同步FIFO

  • 时钟，clk，rst，读写应用同一个时钟；
  • 计数器，count，用计数器来进行空满标志的判断；

异步FIFO

  • 时钟，clk_w，rst_w，clk_r，rst_r，读写应用不同的时钟；
  • 指针，w_pointer_gray，r_pointer_gray，用指针来判断空满标识；
  • 同步指针，w_pointer_gray_sync，r_pointer_gray_sync，指针的同步操作，用来做对比产生空满标志符；

2. 同步FIFO

FIFO主要的设计难点在于如何产生空满标志，在同步FIFO中，我们定义一个计数器，当计数器的值为0时，产生空标志，当计数器的值为FIFO的深度时，产生满标志。基于以上的思想，可以将同步FIFO划分为以下几个模块：write、read、count、RAM。

2.1 模块划分

同步FIFO主要划分为四个模块，RAM模块是用来读取和写入数据；write模块是用来产生写地址；read模块是用来产生读地址；count模块是用来产生空满标志符，每写入一位数，count加一，每读出一位数，count减一。
下面是各个模块的连接框图：

2.2 同步FIFO代码

源文件

1
module fifo_sync
2
    #(
3
         parameter fifo_data_width = 3,
4
         parameter fifo_addr_width = 2
5
     )
6
     (
7
         input clk, rstn, w_en, r_en,
8
         input [fifo_data_width-1:0] data_in,
9
         output reg [fifo_data_width-1:0] data_out,
10
         output full,
11
         output empty
12
     );
13
14
    parameter fifo_depth = 2**fifo_addr_width;
15
16
    reg [fifo_data_width-1:0] mem [fifo_depth-1:0];
17
    reg [fifo_addr_width-1:0] w_addr;
18
    reg [fifo_addr_width-1:0] r_addr;
19
    reg [fifo_addr_width:0] counter;
20
    integer i;
21
22
    // write
23
    always @(posedge clk or negedge rstn)
24
    begin
25
        if (!rstn)
26
        begin
27
            w_addr <= 0;
28
            for (i=0; i<=fifo_depth-1; i=i+1)
29
            begin
30
                mem[i] <= 'b0;
31
            end
32
        end
33
        else if(w_en && ~full)
34
        begin
35
            mem[w_addr] <= data_in;
36
            w_addr <= w_addr + 1;
37
        end
38
    end
39
40
    // read
41
    always @(posedge clk or negedge rstn)
42
    begin
43
        if(!rstn)
44
        begin
45
            r_addr <= 0;
46
            data_out <= 'b0;
47
        end
48
        else if(r_en && ~empty)
49
        begin
50
            data_out <= mem[r_addr];
51
            r_addr <= r_addr + 1;
52
        end
53
    end
54
55
    // update counter
56
    always @(posedge clk or negedge rstn)
57
    begin
58
        if(!rstn)
59
        begin
60
            counter <= 0;
61
        end
62
        else if((w_en && ~full) && ~(r_en && ~empty))
63
        begin
64
            counter <= counter + 1;
65
        end
66
        else if((r_en && ~empty) && ~(w_en && ~full))
67
        begin
68
            counter <= counter - 1;
69
        end
70
    end
71
72
    // flag generate
73
    assign full = (counter == fifo_depth);
74
    assign empty = (counter == 0);
75
76
endmodule //fifo_sync

测试代码

1
`timescale 1ns/1ns
2
module fifo_sync_tb;
3
4
    reg clk,rst,w_en,r_en;
5
    reg [2:0] data_in;
6
7
    wire [2:0] count;
8
    wire [2:0] data_out;
9
10
    reg[2:0] i;
11
12
    initial
13
    begin
14
        clk=0;
15
        rst=1;
16
        data_in=3'b000;
17
        w_en=0;
18
        r_en=0;
19
        #25
20
         rst=0;
21
        #50
22
         rst=1;
23
        #25
24
         w_en=1;
25
        #100
26
         r_en=1;
27
        #100
28
         w_en=0;
29
        r_en=0;
30
        #100
31
         w_en=1;
32
        #400
33
         r_en=1;
34
    end
35
36
    initial
37
    begin
38
        for(i=0;i<=50;i=i+1)
39
            #100 data_in=i;
40
    end
41
42
    always
43
        #50 clk=~clk;
44
45
    fifo_sync  #(.fifo_data_width(3),.fifo_addr_width(2)) ut(
46
                   .clk(clk),
47
                   .rstn(rst),
48
                   .data_in(data_in),
49
                   .data_out(data_out),
50
                   .w_en(w_en),
51
                   .r_en(r_en),
52
                   .full(full),
53
                   .empty(empty)
54
               );
55
endmodule

3. 异步FIFO

异步FIFO的设计难点在于空满标志符的产生，由于异步FIFO的读写是用不同的时钟来控制的，所以不能采用计数器的方法来产生空满标志符，就好像同一个变量不能再两个always块里赋值一样，所以我们必须寻求新的方法来产生空满标志符。

3.1 空满标志

我们知道FIFO的状态是满还是空，他们的相同的判断条件都是w_addr=r_addr，但到底是空还是满我们还不能确定。在这里介绍一种方法来判断空满状态。我们设定一个指针r_pointer_bin，w_pointer_bin，宽度为[FIFO_addr_size:0]，也就是说比传统的地址多一位，我们就用这多出来的一位做空满判断。

  • 如果是满状态的话，也就是说w_pointer_bin比r_pointer_bin多走了一圈，反应在数值上就是w_pointer_bin和r_pointer_bin的最高位不相同。
  • 如果是空状态的话，也就是说w_pointer_bin和r_pointer_bin的路径相同，反应在数值上就是w_pointer_bin和r_pointer_bin的每一位相等。

如下例子所示：
fifo_addr_width=2;fifo_data_addr=3;

3.2 格雷码

将一个时钟域上的指针r_pointer_bin/w_pointer_bin同步到另一个时钟域，如果数据用二进制的方式进行同步的话就会出现多位数据同时跳变的问题，比如3’b011到3’b100即3到4跳变会引起多位数据的改变，这样会大大增加出错的概率。Gray 码就很好的解决了上述问题，gray码相邻数据只有一位跳变，这样就大大降低了数据出错的概率。下面 以一个例子介绍一下二进制码向格雷码的转化的算法。

在不同时钟域进行数据交换的时候我们一般采用格雷码的数据形式进行数据传递，这样能很大程度上降低出错的概率。
引入格雷码同时也引入一个问题，就是数据空满标志的判断不再是二进制时候的判断标准。

  • 如果是空状态的话，无可厚非，仍然是要满足r_pointer_gray和w_pointer_gray每一位都相等。
  • 如果是满状态的话，我们以二进制为例，应该满足r_pointer_bin=3’b111，w_pointer_bin=3’b011，相对应的格雷码应该满足r_pointer_gray=3’b100，w_pointer_gray=3’b010，通俗来讲，满状态要满足r_pointer_gray和w_pointer_gray的高位和次高位相反，其余各位相等。

同时由于格雷码的引入，使得FIFO的深度只能是2的幂次方。

3.3 数据同步

我们知道满状态以后数据就不能进行写入，空状态以后数据就不能进行读出。由此，我们在write模块进行满状态的判断，在read模块进行空状态的判断。

  • 在满状态的判断时，我们要用到r_pointer_gray，为了避免亚稳态，选择两级D触发器相串联构成的同步模块来传送r_pointer_gray，最后用r_pointer_gray_sync和w_pointer_gray相比较产生full信号。
  • 在空状态的判断时，同理我们要用w_pointer_gray_sync和r_pointer_gray相比较产生empty信号。

两拍延时的数据同步对空满标志产生的影响
由此信号r_pointer_gray经过两级D触发器，就会有两拍的延时形成r_pointer_gray_sync信号，所以在进行比较的时候就不是实时的r_pointer_gray与w_pointer_gray进行比较，而是两拍之前的r_pointer_gray即r_pointer_gray_sync与此刻的w_pointer_gray进行比较。那么问题就来了这与我们的本意其实是不相符的，其实是这样的，这是一种最坏情况的考虑，将r_pointer_gray_sync与w_pointer_gray相比较是为了产生full信号，在用于数据同步的这两拍里面有可能再进行读操作，所以用于比较时的读地址一定小于或等于当前的读地址，就算此刻产生full信号，其实FIFO有可能还没有满。这也就为设计留了一些设计的余量。同理，就算有empty信号的产生，FIFO有可能还有数据。这种留余量的设计在实际的工程项目中是很常见的。

3.4 模块的划分

异步FIFO将模块划分为4个部分，RAM、write_full、read_empty、synchronization。RAM根据读写地址进行数据的写入和读出，write_full根据clk_w产生写地址和full信号，read_empty根据clk_r产生读地址和empty信号，synchronization用于同步w_pointer_gray到读时钟域或者同步r_pointer_gray到写时钟域。
下面是各个模块的连接图：

3.5 异步FIFO代码

源文件

  • 顶层文件

    1
    module fifo_top
    2
        #(parameter fifo_addr_width=3, fifo_data_width=2)
    3
         (
    4
             input clk_r, clk_w,
    5
    6
             input rstn_r, rstn_w,
    7
             input w_en, r_en,
    8
             input [fifo_data_width-1:0] data_in,
    9
             output [fifo_data_width-1:0] data_out,
    10
             output full, empty
    11
         );
    12
    13
        wire [fifo_addr_width:0] w_pointer_gray;
    14
        wire [fifo_addr_width:0] r_pointer_gray;
    15
        wire [fifo_addr_width:0] w_pointer_gray_sync;
    16
        wire [fifo_addr_width:0] r_pointer_gray_sync;
    17
        wire [fifo_addr_width-1:0] w_addr;
    18
        wire [fifo_addr_width-1:0] r_addr;
    19
    20
        write_full #(fifo_addr_width)
    21
                   I1(
    22
                       .clk_w(clk_w),
    23
                       .rstn_w(rstn_w),
    24
                       .w_en(w_en),
    25
                       .r_pointer_gray_sync(r_pointer_gray_sync),
    26
    27
                       .w_addr(w_addr),
    28
                       .w_pointer_gray(w_pointer_gray),
    29
                       .full(full)
    30
                   );
    31
    32
        synchronization #(fifo_addr_width)
    33
                        I2(
    34
                            .clk(clk_w),
    35
                            .rstn(rstn_w),
    36
                            .din(w_pointer_gray),
    37
                            .dout(w_pointer_gray_sync)
    38
                        );
    39
    40
        read_empty #(fifo_addr_width)
    41
                   I3(
    42
                       .clk_r(clk_r),
    43
                       .rstn_r(rstn_r),
    44
                       .r_en(r_en),
    45
                       .w_pointer_gray_sync(w_pointer_gray_sync),
    46
    47
                       .r_addr(r_addr),
    48
                       .r_pointer_gray(r_pointer_gray),
    49
                       .empty(empty)
    50
                   );
    51
    52
        synchronization #(fifo_addr_width)
    53
                        I4(
    54
                            .clk(clk_r),
    55
                            .rstn(rstn_r),
    56
                            .din(r_pointer_gray),
    57
                            .dout(r_pointer_gray_sync)
    58
                        );
    59
    60
        ram #(fifo_data_width, fifo_addr_width)
    61
            I5(
    62
                .clk_r(clk_r),
    63
                .clk_w(clk_w),
    64
                .rstn_r(rstn_r),
    65
                .rstn_w(rstn_w),
    66
                .r_en(r_en),
    67
                .w_en(w_en),
    68
                .data_in(data_in),
    69
                .r_addr(r_addr),
    70
                .w_addr(w_addr),
    71
                .full(full),
    72
                .empty(empty),
    73
    74
                .data_out(data_out)
    75
            );
    76
    77
    endmodule

RAM

1
module ram #(parameter fifo_data_width = 3, fifo_addr_width = 2) (
2
        input clk_r, clk_w,
3
        input rstn_r, rstn_w,
4
        input w_en, r_en,
5
        input [fifo_addr_width-1:0] r_addr,
6
        input [fifo_addr_width-1:0] w_addr,
7
        input [fifo_data_width-1:0] data_in,
8
        input empty, full,
9
10
        output reg [fifo_data_width-1:0] data_out
11
    );
12
    parameter fifo_depth = 2**fifo_addr_width;
13
    reg [fifo_data_width-1:0] mem[fifo_depth-1:0];
14
    integer i;
15
16
    // write
17
    always @(posedge clk_w or negedge rstn_w)
18
    begin
19
        if (!rstn_w)
20
        begin
21
            for(i=0; i<=fifo_depth-1; i=i+1)
22
            begin
23
                mem[i] <= 'b0;
24
            end
25
        end
26
        else if(w_en && (~full))
27
        begin
28
            mem[w_addr] <= data_in;
29
        end
30
    end
31
32
    // read
33
    always @(posedge clk_r or negedge rstn_r)
34
    begin
35
        if(!rstn_r)
36
        begin
37
            data_out <= 'b0;
38
        end
39
        else if(r_en && (~empty))
40
        begin
41
            data_out <= mem[r_addr];
42
        end
43
    end
44
45
endmodule //ram

write_full

1
module write_full #(parameter fifo_addr_width = 2)(
2
        input clk_w,
3
        input rstn_w,
4
        input w_en,
5
        input [fifo_addr_width:0] r_pointer_gray_sync,
6
        output full,
7
        output [fifo_addr_width-1:0] w_addr,
8
        output [fifo_addr_width:0] w_pointer_gray
9
    );
10
11
12
    reg [fifo_addr_width:0] w_pointer_bin;
13
14
15
    always @(posedge clk_w or negedge rstn_w)
16
    begin
17
        if (!rstn_w)
18
        begin
19
            w_pointer_bin <= 'b0;
20
        end
21
        else if (w_en && ~full)
22
        begin
23
            w_pointer_bin <= w_pointer_bin + 1;
24
        end
25
    end
26
27
    assign w_pointer_gray = (w_pointer_bin >> 1) ^ w_pointer_bin;
28
    assign w_addr = w_pointer_bin[fifo_addr_width-1:0];
29
    assign full = (w_pointer_gray == {~r_pointer_gray_sync[fifo_addr_width:fifo_addr_width-1], r_pointer_gray_sync[fifo_addr_width-2:0]});
30
31
32
endmodule //write_full

read_empty

1
module read_empty #(parameter fifo_addr_width = 2) (
2
        input clk_r,
3
        input rstn_r,
4
        input r_en,
5
        input [fifo_addr_width:0] w_pointer_gray_sync,
6
        output empty,
7
        output [fifo_addr_width:0] r_pointer_gray,
8
        output [fifo_addr_width-1:0] r_addr
9
    );
10
11
    reg [fifo_addr_width:0] r_pointer_bin;
12
13
    always @(posedge clk_r or negedge rstn_r)
14
    begin
15
        if (!rstn_r)
16
        begin
17
            r_pointer_bin <= 'b0;
18
        end
19
        else if(r_en && (~empty))
20
        begin
21
            r_pointer_bin <= r_pointer_bin + 1;
22
        end
23
    end
24
25
    assign r_pointer_gray = (r_pointer_bin >> 1) ^ r_pointer_bin;
26
    assign r_addr = r_pointer_bin[fifo_addr_width-1:0];
27
    assign empty = (r_pointer_gray == w_pointer_gray_sync);
28
29
endmodule //read_empty

synchronization

1
module synchronization #(parameter fifo_addr_width =2) (
2
        input clk,
3
        input rstn,
4
        input [fifo_addr_width:0] din,
5
        output reg [fifo_addr_width:0] dout
6
    );
7
8
    reg [fifo_addr_width:0] d1;
9
    always @(posedge clk or negedge rstn)
10
    begin
11
        if(!rstn)
12
        begin
13
            d1 <= 'b0;
14
            dout <= 'b0;
15
        end
16
        else
17
        begin
18
            d1 <= din;
19
            dout <= d1;
20
        end
21
    end
22
23
endmodule //synchronization

测试文件

1
`timescale 1ns/1ns
2
module fifo_async_tb;
3
4
    parameter fifo_data_width=3,
5
              fifo_addr_width=2;
6
7
    reg clk_r, rstn_r, w_en, r_en, clk_w, rstn_w;
8
    reg [fifo_data_width-1:0] data_in;
9
    wire [fifo_data_width-1:0] data_out;
10
    wire empty,full;
11
12
    reg [fifo_data_width-1:0] i;
13
14
    initial
15
    begin
16
        clk_w=0;
17
        rstn_w=1;
18
        data_in={fifo_data_width{1'b0}};
19
        #15
20
         rstn_w=0;
21
        #20
22
         rstn_w=1;
23
    end
24
25
    initial
26
    begin
27
        clk_r=0;
28
        rstn_r=1;
29
        r_en=0;
30
        #25
31
         rstn_r=0;
32
        #50
33
         rstn_r=1;
34
    end
35
36
    initial
37
    begin
38
        w_en=0;
39
        #450
40
         w_en=1;
41
        #400
42
         w_en=0;
43
        #750
44
         w_en=1;
45
    end
46
47
    initial
48
    begin
49
        r_en=0;
50
        #900
51
         r_en=1;
52
        #400
53
         r_en=0;
54
        #300
55
         r_en=1;
56
    end
57
58
    initial
59
    begin
60
        for(i=0;i<=50;i=i+1)
61
            #100 data_in=i;
62
    end
63
64
    always
65
        #25 clk_w=~clk_w;
66
    always
67
        #50 clk_r=~clk_r;
68
69
70
    fifo_top #(.fifo_data_width(fifo_data_width),.fifo_addr_width(fifo_addr_width))
71
             u1(.clk_w(clk_w),
72
                .rstn_w(rstn_w),
73
                .w_en(w_en),
74
                .clk_r(clk_r),
75
                .rstn_r(rstn_r),
76
                .r_en(r_en),
77
                .data_in(data_in),
78
                .data_out(data_out),
79
                .empty(empty),
80
                .full(full)
81
               );
82
83
endmodule

4. FIFO的深度计算

其实FIFO的深度可大可小，并没有一个具体的公式能够精确计算出FIFO深度的大小。在FIFO实际工作中，其数据的满/空标志可以控制数据的继续写入或读出。在一个具体的应用中也不可能由一些参数算出精确的所需FIFO深度为多少，这在写速度大于读速度的理想状态下是可行的，但在实际中用到的FIFO深度往往要大于计算值。一般来说根据电路的具体情况，在兼顾系统性能和FIFO成本的情况下估算一个大概的宽度和深度就可以了。而对于写速度慢于读速度的应用，FIFO的深度要根据读出的数据结构和读出数据的那些具体的要求来确定。下面我们以一道简单的题目来估算一下FIFO的深度。
一个8bit宽的异步FIFO，输入时钟为100MHz，输出时钟为95MHz，设一个package为4Kbit，且两个package之间的发送间距足够大。问异步FIFO的深度。
解答：8bit位宽的异步FIFO，一个package的大小为41024/8=512Word，100MHz的输入时钟，传送一个Word需要的时间为1/100MHz，则发送一个package需要的时间T=512/100MHz，95MHz的输出时钟，接受一个Word需要的时间为1/95MHz，发送一个package的时间所能接受的数据量为(512\95)/100word=486.4word，所以FIFO的深度至少为512-486.4=25.6=26。

计算公式：Depth=Burst_length - Brust_length*(rd_clk/wr_clk)\*rd_rate