异步FIFO的设计_[datasize-1:0] mem [0:depth-1]

本文首先对异步 FIFO 设计的重点难点进行分析

最后给出详细代码

---

一、FIFO简单讲解

FIFO的本质是RAM， 先进先出

重要参数：fifo深度（简单来说就是需要存多少个数据）

              fifo位宽（每个数据的位宽）

FIFO有同步和异步两种，同步即读写时钟相同，异步即读写时钟不相同

同步FIFO用的少，可以作为数据缓存

异步FIFO可以解决跨时钟域的问题，在应用时需根据实际情况考虑好fifo深度即可

---

本次要设计一个异步FIFO，深度为8，位宽也是8.

代码是学习Simulation and Synthesis Techniques for Asynchronous FIFO Design   Clifford E. Cummings, Sunburst Design, Inc.这篇文章的，

百度搜搜很容易找到，虽然是英文的但是写的确实值得研究。

下面我会对设计的要点进行分析，也是对自己学习过程的一个总结，希望能和大家交流共同进步。

---

二、设计要点解析

1、读空信号如何产生？写满信号如何产生？

读空信号：复位的时候，读指针和写指针相等，读空信号有效（这里所说的指针其实就是读地址、写地址）

              当读指针赶上写指针的时候，写指针等于读指针意味着最后一个数据被读完，此时读空信号有效

写满信号：当写指针比读指针多一圈时，写指针等于读指针意味着写满了，此时写满信号有效

我们会发现 读空的条件是写指针等于读指针，写满的条件也是写指针等于读指针，到底如何区分呢？

解决方法：将指针的位宽多定义一位

举个例子说明：假设要设计深度为 8 的异步FIFO，此时定义读写指针只需要 3 位（2^3=8）就够用了，

但是我们在设计时将指针的位宽设计成 4 位，最高位的作用就是区分是读空还是写满，具体理论 1 如下

当最高位相同，其余位相同认为是读空

当最高位不同，其余位相同认为是写满

注意：理论1试用的是二进制数之间的空满比较判断。

但是这篇文章中确不是这样比较的，而是用的理论2，这里我解释一下

由于文章在设计中判断是读指针是否等于写指针的时候，用的是读写指针的格雷码形式（为什么用格雷码后面解释），此时若用上面的理论1就会出问题，

因为格雷码是镜像对称的，若只根据最高位是否相同来区分是读空还是写满是有问题的，详情我会慢慢说，请看图 1

绿色框起来的是0--15的格雷码，用红线将格雷码分为上下两部分

通过观察格雷码相邻位每次只有1位发生变化，且上下两部分，除了最高位相反，其余位全都关于红线镜像对称，

7 --> 8 ，格雷码从 0100 --> 1100 ,只有最高位发生变化其余位相同

6 --> 9  , 格雷码从 0101 --> 1101 , 只有最高位发生变化其余位相同

以此类推，为什么要说镜像对称呢？

试想如果读指针指向 8，写指针指向 7 ，我们可以知道此时此刻并不是读空状态也不是写满状态

但是如果在此刻套用理论 1 来判断，看会出现什么情况，我们来套一下

7的格雷码与8的格雷码的最高位不同，其余位相同，所以判断出为写满。这就出现误判了，同样套用在 6 和 9，5 和 10等也会出现误判。

因此用格雷码判断是否为读空或写满时应使用理论 2，看最高位和次高位是否相等，具体如下：

当最高位和次高位相同，其余位相同认为是读空

当最高位和次高位不同，其余位相同认为是写满

补：理论2这个判断方法适用于用格雷码判断比较空满

在实际设计中如果不想用格雷码比较，就可以利用格雷码将读写地址同步到一个时钟域后再将格雷码再次转化成二进制数再用理论1进行比较就好了。。

                                                  图 1

2、由于是异步FIFO的设计，读写时钟不一样，在产生读空信号和写满信号时，会涉及到跨时钟域的问题，如何解决？

跨时钟域的问题：上面我们已经提到要通过比较读写指针来判断产生读空和写满信号

但是读指针是属于读时钟域的，写指针是属于写时钟域的，而异步FIFO的读写时钟域不同，是异步的，

要是将读时钟域的读指针与写时钟域的写指针不做任何处理直接比较肯定是错误的，因此我们需要进行同步处理以后仔进行比较

解决方法：两级寄存器同步 + 格雷码

同步的过程有两个：

（1）将写时钟域的写指针同步到读时钟域，将同步后的写指针与读时钟域的读指针进行比较产生读空信号

（2）将读时钟域的读指针同步到写时钟域，将同步后的读指针与写时钟域的写指针进行比较产生写满信号

同步的思想就是用两级寄存器同步，简单说就是打两拍，相信有点基础的早都烂熟于心，就不再多做解释，不懂的可以看看代码结合理解。

只是这样简单的同步就可以了吗？no no no ，可怕的亚稳态还在等着你。

 我们如果直接用二进制编码的读写指针去完成上述的两种同步是不行的，使用格雷码更合适，为什么呢？

因为二进制编码的指针在跳变的时候有可能是多位数据一起变化，如二进制的7-->8 即 0111 --> 1000 ,在跳变的过程中 4 位全部发生了改变，这样很容易产生毛刺，例如

异步FIFO的写指针和读指针分属不同时钟域，这样指针在进行同步过程中很容易出错，比如写指针在从0111到1000跳变时4位同时改变，这样读时钟在进行写指针同步后得到的写指针可能是0000-1111的某个值，一共有2^4个可能的情况，而这些都是不可控制的，你并不能确定会出现哪个值，那出错的概率非常大，怎么办呢？到了格雷码发挥作用的时候了，而格雷码的编码特点是相邻位每次只有 1 位发生变化， 这样在进行指针同步的时候，只有两种可能出现的情况：1.指针同步正确，正是我们所要的；2.指针同步出错，举例假设格雷码写指针从000->001，将写指针同步到读时钟域同步出错，出错的结果只可能是000->000，因为相邻位的格雷码每次只有一位变化，这个出错结果实际上也就是写指针没有跳变保持不变，我们所关心的就是这个错误会不会导致读空判断出错？答案是不会，最多是让空标志在FIFO不是真正空的时候产生，而不会出现空读的情形。所以gray码保证的是同步后的读写指针即使在出错的情形下依然能够保证FIFO功能的正确性。在同步过程中的亚稳态不可能消除，但是我们只要保证它不会影响我们的正常工作即可。

3、由于设计的时候读写指针用了至少两级寄存器同步，同步会消耗至少两个时钟周期，势必会使得判断空或满有所延迟，这会不会导致设计出错呢？

异步FIFO通过比较读写指针进行满空判断，但是读写指针属于不同的时钟域，所以在比较之前需要先将读写指针进行同步处理，

将写指针同步到读时钟域再和读指针比较进行FIFO空状态判断，因为在同步写指针时需要时间，而在这个同步的时间内有可能还会写入新的数据，因此同步后的写指针一定是小于或者等于当前实际的写指针，所以此时判断FIFO为空不一定是真空，这样更加保守，一共不会出现空读的情况，虽然会影响FIFO的性能，但是并不会出错，同理将读指针同步到写时钟域再和写指针比较进行FIFO满状态判断，同步后的读指针一定是小于或者等于当前的读指针，所以此时判断FIFO为满不一定是真满，这样更保守，这样可以保证FIFO的特性：FIFO空之后不能继续读取，FIFO满之后不能继续写入。总结来说异步逻辑转到同步逻辑不可避免需要额外的时钟开销，这会导致满空趋于保守，但是保守并不等于错误，这么写会稍微有性能损失，但是不会出错。

举个例子：大多数情形下，异步FIFO两端的时钟不是同频的，或者读快写慢，或者读慢写快，慢的时钟域同步到快的时钟域不会出现漏掉指针的情况，但是将指针从快的时钟域同步到慢的时钟域时可能会有指针遗漏，举个例子以读慢写快为例，进行满标志判断的时候需要将读指针同步到写时钟域，因为读慢写快，所以不会有读指针遗漏，同步消耗时钟周期，所以同步后的读指针滞后（小于等于）当前读地址，所以可能满标志会提前产生，满并非真满。进行空标志判断的时候需要将写指针同步到读指针 ，因为读慢写快，所以当读时钟同步写指针 的时候，必然会漏掉一部分写指针，我们不用关心那到底会漏掉哪些写指针，我们在乎的是漏掉的指针会对FIFO的空标志产生影响吗？比如写指针从0写到10，期间读时钟域只同步捕捉到了3、5、8这三个写指针而漏掉了其他指针。当同步到8这个写指针时，真实的写指针可能已经写到10 ，相当于在读时钟域还没来得及觉察的情况下，写时钟域可能偷偷写了数据到FIFO去，这样在判断它是不是空的时候会出现不是真正空的情况，漏掉的指针也没有对FIFO的逻辑操作产生影响。

4、多位二进制码如何转化为格雷码

二进制码转换成二进制格雷码，其法则是保留二进制码的最高位作为格雷码的最高位，而次高位格雷码为二进制码的高位与次高位相异或，而格雷码其余各位与次高位的求法相类似。 
　　

我再换种更简单的描述 

二进制数                                       1 0 1 1 0

二进制数右移1位，空位补0               0 1 0 1 1

异或运算                                       1 1 1 0 1  

这样就可以实现二进制到格雷码的转换了，总结就是移位并且异或，verilog代码实现就一句：assign wgraynext = (wbinnext>>1) ^ wbinnext;

三、代码解析

异步FIFO的信号接口：

wclk  wrst_n  winc wdata //写时钟、写复位、写请求、写数据     这几个与写有关的全部与wclk同步

rclk  rrst_n    rinc   rdata //读时钟、读 复位、读 请求、读 数据    这几个与读有关的全部与rclk同步

wfull                              //写满  与wclk同步

rempty                          // 读空 与rclk同步

本次代码共分为6个module

1、fifo.v  是顶层模块，作用是将各个小模块例化联系起来

module fifo
#(
  parameter DSIZE = 8,        
  parameter ASIZE = 4
 ) 
 (
     output [DSIZE-1:0] rdata,  
     output             wfull,  
     output             rempty,  
     input  [DSIZE-1:0] wdata,  
     input              winc, wclk, wrst_n, 
     input              rinc, rclk, rrst_n
 );
 
  wire   [ASIZE-1:0] waddr, raddr;  
  wire   [ASIZE:0]   wptr, rptr, wq2_rptr, rq2_wptr;
// synchronize the read pointer into the write-clock domain
  sync_r2w  sync_r2w
  (
                    .wq2_rptr    (wq2_rptr),
                    .rptr        (rptr    ),                          
                    .wclk        (wclk    ), 
                    .wrst_n      (wrst_n  )  
 );
 
// synchronize the write pointer into the read-clock domain
  sync_w2r  sync_w2r 
  (
                   .rq2_wptr(rq2_wptr), 
                   .wptr(wptr),                          
                   .rclk(rclk),
                   .rrst_n(rrst_n)
 );
 
//this is the FIFO memory buffer that is accessed by both the write and read clock domains.
//This buffer is most likely an instantiated, synchronous dual-port RAM. 
//Other memory styles can be adapted to function as the FIFO buffer. 
  fifomem 
  #(DSIZE, ASIZE)
  fifomem                        
  (
      .rdata(rdata), 
      .wdata(wdata),                           
      .waddr(waddr),
      .raddr(raddr),                           
      .wclken(winc),
      .wfull(wfull),                           
      .wclk(wclk)
  );
 
//this module is completely synchronous to the read-clock domain and contains the FIFO read pointer and empty-flag logic.  
  rptr_empty
  #(ASIZE)    
  rptr_empty                          
  (
      .rempty(rempty),                          
      .raddr(raddr),                          
      .rptr(rptr),
      .rq2_wptr(rq2_wptr),                          
      .rinc(rinc),
      .rclk(rclk),                          
      .rrst_n(rrst_n)
  );
 
//this module is completely synchronous to the write-clock domain and contains the FIFO write pointer and full-flag logic
  wptr_full 
  #(ASIZE)    
  wptr_full                         
  (
      .wfull(wfull),
      .waddr(waddr),  
      .wptr(wptr),
      .wq2_rptr(wq2_rptr),    
      .winc(winc),
      .wclk(wclk),        
      .wrst_n(wrst_n)
  );
  endmodule

2、fifomem.v  生成存储实体，FIFO 的本质是RAM,因此在设计存储实体的时候有两种方法：用数组存储数据或者调用RAM的IP核 

module fifomem
#(
    parameter  DATASIZE = 8, // Memory data word width               
    parameter  ADDRSIZE = 4  // 深度为8即地址为3位即可，这里多定义一位的原因是用来判断是空还是满，详细在后文讲到
) // Number of mem address bits
(
    output [DATASIZE-1:0] rdata, 
    input  [DATASIZE-1:0] wdata, 
    input  [ADDRSIZE-1:0] waddr, raddr, 
    input                 wclken, wfull, wclk
);
 
`ifdef RAM   //可以调用一个RAM IP核
// instantiation of a vendor's dual-port RAM 
my_ram  mem
      (
          .dout(rdata),
          .din(wdata),     
          .waddr(waddr),
          .raddr(raddr),   
          .wclken(wclken), 
          .wclken_n(wfull),
          .clk(wclk)
      );
  `else  //用数组生成存储体
 // RTL Verilog memory model
localparam DEPTH = 1<<ADDRSIZE;   // 左移相当于乘法，2^4
reg [DATASIZE-1:0] mem [0:DEPTH-1]; //生成2^4个位宽位8的数组
assign rdata = mem[raddr];
always @(posedge wclk)  //当写使能有效且还未写满的时候将数据写入存储实体中，注意这里是与wclk同步的
    if (wclken && !wfull)
        mem[waddr] <= wdata;
 `endif
 endmodule

3、sync_r2w.v 将 rclk 时钟域的格雷码形式的读指针同步到 wclk 时钟域，简单来讲就是用两级寄存器同步，即打两拍

module sync_r2w
#(
    parameter ADDRSIZE = 4
)
(
    output reg [ADDRSIZE:0] wq2_rptr,   //读指针同步到写时钟域
    input      [ADDRSIZE:0] rptr,       // 格雷码形式的读指针，格雷码的好处后面会细说 
    input                   wclk, wrst_n
);
 
reg [ADDRSIZE:0] wq1_rptr;
 
  always @(posedge wclk or negedge wrst_n)   
      if (!wrst_n) begin
          wq1_rptr <= 0;          
          wq2_rptr <= 0;
      end           
      else begin        
          wq1_rptr<= rptr;
          wq2_rptr<=wq1_rptr;
      end          
  endmodule

4、sync_w2r.v 将 wclk 时钟域的格雷码形式的写指针同步到 rclk 时钟域

module sync_w2r
#(parameter ADDRSIZE = 4)
(
    output reg [ADDRSIZE:0] rq2_wptr, //写指针同步到读时钟域
    input      [ADDRSIZE:0] wptr,     //格雷码形式的写指针
    input                   rclk, rrst_n
);
 
reg [ADDRSIZE:0] rq1_wptr;
 
  always @(posedge rclk or negedge rrst_n)   
      if (!rrst_n)begin
          rq1_wptr <= 0;
          rq2_wptr <= 0;
      end 
      else begin
          rq1_wpt <= wptr;
          rq2_wptr <= rq1_wptr;
      end
        
endmodule

5、rptr_empty.v 将 sync_w2r.v 同步后的写指针与 rclk 时钟域的读指针进行比较生成都空信号

module rptr_empty
#(
    parameter ADDRSIZE = 4
)
(
    output reg                rempty, 
    output     [ADDRSIZE-1:0] raddr,  //二进制形式的读指针
    output reg [ADDRSIZE  :0] rptr,  //格雷码形式的读指针
    input      [ADDRSIZE  :0] rq2_wptr, //同步后的写指针
    input                     rinc, rclk, rrst_n
);
  reg  [ADDRSIZE:0] rbin;
  wire [ADDRSIZE:0] rgraynext, rbinnext;
 // GRAYSTYLE2 pointer
 //将二进制的读指针与格雷码进制的读指针同步
  always @(posedge rclk or negedge rrst_n) 
      if (!rrst_n) begin
          rbin <= 0;
          rptr <= 0;
      end  
      else begin        
          rbin<=rbinnext; //直接作为存储实体的地址
          rptr<=rgraynext;//输出到 sync_r2w.v模块，被同步到 wrclk 时钟域
      end
  // Memory read-address pointer (okay to use binary to address memory)
  assign raddr     = rbin[ADDRSIZE-1:0]; //直接作为存储实体的地址，比如连接到RAM存储实体的读地址端。
  assign rbinnext  = rbin + (rinc & ~rempty); //不空且有读请求的时候读指针加1
  assign rgraynext = (rbinnext>>1) ^ rbinnext; //将二进制的读指针转为格雷码
  // FIFO empty when the next rptr == synchronized wptr or on reset 
  assign rempty_val = (rgraynext == rq2_wptr); //当读指针等于同步后的写指针，则为空。
  always @(posedge rclk or negedge rrst_n) 
      if (!rrst_n)
          rempty <= 1'b1; 
      else     
          rempty <= rempty_val;
 
endmodule

6、wptr_full.v 将  sync_r2w.v 同步后的读指针与wclk 时钟域的写指针进行比较生成写满信号

module wptr_full
#(
    parameter ADDRSIZE = 4
) 
(
    output reg                wfull,   
    output     [ADDRSIZE-1:0] waddr,
    output reg [ADDRSIZE  :0] wptr, 
    input      [ADDRSIZE  :0] wq2_rptr,
    input                     winc, wclk, wrst_n
);
  reg  [ADDRSIZE:0] wbin;
  wire [ADDRSIZE:0] wgraynext, wbinnext;
  // GRAYSTYLE2 pointer
  always @(posedge wclk or negedge wrst_n)   
      if (!wrst_n)
          {wbin, wptr} <= 0;   
      else         
          {wbin, wptr} <= {wbinnext, wgraynext};
  // Memory write-address pointer (okay to use binary to address memory) 
  assign waddr = wbin[ADDRSIZE-1:0];
  assign wbinnext  = wbin + (winc & ~wfull);
  assign wgraynext = (wbinnext>>1) ^ wbinnext; //二进制转为格雷码
  //-----------------------------------------------------------------
  assign wfull_val = (wgraynext=={~wq2_rptr[ADDRSIZE:ADDRSIZE-1],wq2_rptr[ADDRSIZE-2:0]}); //当最高位和次高位不同其余位相同时则写指针超前于读指针一圈，即写满。后面会详细解释。
  always @(posedge wclk or negedge wrst_n)
      if (!wrst_n)
          wfull  <= 1'b0;   
      else     
          wfull  <= wfull_val;
 
  endmodule

7、测试文件

`timescale 1ns /1ns 
 
module test();
reg  [7:0] wdata;
reg           winc, wclk, wrst_n; 
reg           rinc, rclk, rrst_n;
wire [7:0] rdata;  
wire           wfull;  
wire          rempty;  
 
fifo
 
u_fifo (
               .rdata(rdata),  
               .wfull(wfull),  
               .rempty(rempty),  
               .wdata (wdata),  
               .winc  (winc), 
               .wclk  (wclk), 
               .wrst_n(wrst_n), 
               .rinc(rinc), 
               .rclk(rclk), 
               .rrst_n(rrst_n)
 );
localparam CYCLE = 20;
localparam CYCLE1 = 40;
 
 
 
        //时钟周期，单位为ns，可在此修改时钟周期。
     
            //生成本地时钟50M
            initial begin
                wclk = 0;
                forever
                #(CYCLE/2)
                wclk=~wclk;
            end
            initial begin
                rclk = 0;
                forever
                #(CYCLE1/2)
                rclk=~rclk;
            end
 
            //产生复位信号
            initial begin
                wrst_n = 1;
                #2;
                wrst_n = 0;
                #(CYCLE*3);
                wrst_n = 1;
            end
            
             initial begin
                rrst_n = 1;
                #2;
                rrst_n = 0;
                #(CYCLE*3);
                rrst_n = 1;
            end
 
            always  @(posedge wclk or negedge wrst_n)begin
                if(wrst_n==1'b0)begin
                    winc <= 0;
                    rinc <= 0;
                end
                else begin
                    winc <= $random;
                    rinc <= $random;
                end
            end
            always  @(posedge rclk or negedge rrst_n)begin
                if(rrst_n==1'b0)begin                  
                    rinc <= 0;
                end
                else begin                
                    rinc <= $random;
                end
            end
always@(*)begin
  if(winc == 1)
    wdata= $random ;
  else
    wdata = 0;
end  
endmodule

8、仿真结果图