异步FIFO及verilog原码

　这几天看了Clifford E. Cummings的两篇大作《Simulation and Synthesis Techniques for Asynchronous FIFO Design》and 《Simulation and Synthesis Techniques for Asynchronous FIFO Design with Asynchronous Pointer Comparisons》颇有感想，真可谓经典之作，不可错过。

1．什么是FIFO？

FIFO是英文First In First Out 的缩写，是一种先进先出的数据缓存器，他与普通存储器的区别是没有外部读写地址线，这样使用起来非常简单，但缺点就是只能顺序写入数据，顺序的读出数据，其数据地址由内部读写指针自动加1完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。

2．什么情况下用FIFO？

FIFO一般用于不同时钟域之间的数据传输，比如FIFO的一端是AD数据采集，另一端是计算机的PCI总线，假设其AD采集的速率为16位 100K SPS，那么每秒的数据量为100K×16bit=1.6Mbps,而PCI总线的速度为33MHz，总线宽度32bit,其最大传输速率为1056Mbps,在两个不同的时钟域间就可以采用FIFO来作为数据缓冲。

另外对于不同宽度的数据接口也可以用FIFO，例如单片机位8位数据输出，而DSP可能是16位数据输入，在单片机与DSP连接时就可以使用FIFO来达到数据匹配的目的。

3．FIFO的一些重要参数

FIFO的宽度：也就是英文资料里常看到的THE WIDTH，它只的是FIFO一次读写操作的数据位，就像MCU有8位和16位，ARM 32位等等，FIFO的宽度在单片成品IC中是固定的，也有可选择的，如果用FPGA自己实现一个FIFO，其数据位，也就是宽度是可以自己定义的。

FIFO的深度：THE DEEPTH，它指的是FIFO可以存储多少个N位的数据（如果宽度为N）。如一个8位的FIFO，若深度为8，它可以存储8个8位的数据，深度为12 ，就可以存储12个8位的数据，FIFO的深度可大可小，个人认为FIFO深度的计算并无一个固定的公式。在FIFO实际工作中，其数据的满/空标志可以控制数据的继续写入或读出。在一个具体的应用中也不可能由一些参数算数精确的所需FIFO深度为多少，这在写速度大于读速度的理想状态下是可行的，但在实际中用到的FIFO深度往往要大于计算值。一般来说根据电路的具体情况，在兼顾系统性能和FIFO成本的情况下估算一个大概的宽度和深度就可以了。而对于写速度慢于读速度的应用，FIFO的深度要根据读出的数据结构和读出数据的由那些具体的要求来确定。

满标志：FIFO已满或将要满时由FIFO的状态电路送出的一个信号，以阻止FIFO的写操作继续向FIFO中写数据而造成溢出（overflow）。

空标志：FIFO已空或将要空时由FIFO的状态电路送出的一个信号，以阻止FIFO的读操作继续从FIFO中读出数据而造成无效数据的读出（underflow）。

读时钟：读操作所遵循的时钟，在每个时钟沿来临时读数据。

写时钟：写操作所遵循的时钟，在每个时钟沿来临时写数据。

读指针：指向下一个读出地址。读完后自动加1。

写指针：指向下一个要写入的地址的，写完自动加1。

读写指针其实就是读写的地址，只不过这个地址不能任意选择，而是连续的。

4．FIFO的分类

根均FIFO工作的时钟域，可以将FIFO分为同步FIFO和异步FIFO。同步FIFO是指读时钟和写时钟为同一个时钟。在时钟沿来临时同时发生读写操作。异步FIFO是指读写时钟不一致，读写时钟是互相独立的。

5．FIFO设计的难点

FIFO设计的难点在于怎样判断FIFO的空/满状态。为了保证数据正确的写入或读出，而不发生益处或读空的状态出现，必须保证FIFO在满的情况下，不能进行写操作。在空的状态下不能进行读操作。怎样判断FIFO的满/空就成了FIFO设计的核心问题。由于同步FIFO几乎很少用到，这里只描述异步FIFO的空/满标志产生问题。在用到触发器的设计中，不可避免的会遇到亚稳态的问题（关于亚稳态这里不作介绍，可查看相关资料）。

在涉及到触发器的电路中，亚稳态无法彻底消除，只能想办法将其发生的概率将到最低。其中的一个方法就是使用格雷码。格雷码在相邻的两个码元之间只由一位变换(二进制码在很多情况下是很多码元在同时变化)。这就会避免计数器与时钟同步的时候发生亚稳态现象。但是格雷码有个缺点就是只能定义2^n的深度，而不能像二进制码那样随意的定义FIFO的深度，因为格雷码必须循环一个2^n，否则就不能保证两个相邻码元之间相差一位的条件，因此也就不是真正的各雷码了。

第二就是使用冗余的触发器，假设一个触发器发生亚稳态的概率为P，那么两个及联的触发器发生亚稳态的概率就为P的平方。但这回导致延时的增加。亚稳态的发生会使得FIFO出现错误，读/写时钟采样的地址指针会与真实的值之间不同，这就导致写入或读出的地址错误。由于考虑延时的作用，空/满标志的产生并不一定出现在FIFO真的空/满时才出现。可能FIFO还未空/满时就出现了空/满标志。这并没有什么不好，只要保证FIFO不出现overflow or underflow 就OK了。

很多关于FIFO的文章其实讨论的都是空/满标志的不同算法问题。

 

第一个算法：Clifford E. Cummings的文章中提到的STYLE #1，构造一个指针宽度为N+1，深度为2^N字节的FIFO（为便方比较将格雷码指针转换为二进制指针）。当指针的二进制码中最高位不一致而其它N位都相等时，FIFO为满（在Clifford E. Cummings的文章中以格雷码表示是前两位均不相同，而后两位LSB相同为满，这与换成二进制表示的MSB不同其他相同为满是一样的）。当指针完全相等时，FIFO为空。

  这种方法思路非常明了，为了比较不同时钟产生的指针，需要把不同时钟域的信号同步到本时钟域中来，而使用Gray码的目的就是使这个异步同步化的过程发生亚稳态的机率最小，而为什么要构造一个N+1的指针，Clifford E. Cummings也阐述的很明白，有兴趣的读者可以看下作者原文是怎么论述的，Clifford E. Cummings的这篇文章有Rev1.1 Rev1.2两个版本，两者在比较Gray码指针时的方法略有不同，个Rev1.2版更为精简。

第二种算法：Clifford E. Cummings的文章中提到的STYLE #2。它将FIFO地址分成了4部分，每部分分别用高两位的MSB 00 、01、 11、 10决定FIFO是否为going full 或going empty (即将满或空)。如果写指针的高两位MSB小于读指针的高两位MSB则FIFO为“几乎满”，若写指针的高两位MSB大于读指针的高两位MSB则FIFO为“几乎空”。

它是利用将地址空间分成4个象限（也就是四个等大小的区域），然后观察两个指针的相对位置，如果写指针落后读指针一个象限（25%的距离，呵呵），则证明很可能要写满，反之则很可能要读空，这个时候分别设置两个标志位dirset和dirrst，然后在地址完全相等的情况下，如果dirset有效就是写满，如果dirrst有效就是读空。

这种方法对深度为2^N字节的FIFO只需N位的指针即可，处理的速度也较第一种方法快。

两篇文章的原码

//----------------------STYLE #1--------------------------

module fifo1(rdata, wfull, rempty, wdata, winc, wclk, wrst_n,rinc, rclk, rrst_n);
      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;
  
  reg wfull,rempty;
  reg [ASIZE:0] wptr, rptr, wq2_rptr, rq2_wptr, wq1_rptr,rq1_wptr;
  reg [ASIZE:0] rbin, wbin;
  reg [DSIZE-1:0] mem[0:(1<<ASIZE)-1];
  wire [ASIZE-1:0] waddr, raddr;
  wire [ASIZE:0]  rgraynext, rbinnext,wgraynext,wbinnext;
  wire  rempty_val,wfull_val;
//-----------------双口RAM存储器--------------------
   assign rdata=mem[raddr];
   always@(posedge wclk)
     if (winc && !wfull) mem[waddr] <= wdata;
//-------------同步rptr 指针-------------------------
   always @(posedge wclk or negedge wrst_n)
          if (!wrst_n) {wq2_rptr,wq1_rptr} <= 0;
          else {wq2_rptr,wq1_rptr} <= {wq1_rptr,rptr};
//-------------同步wptr指针---------------------------
    always @(posedge rclk or negedge rrst_n)
        if (!rrst_n) {rq2_wptr,rq1_wptr} <= 0;
        else {rq2_wptr,rq1_wptr} <= {rq1_wptr,wptr};
//-------------rempty产生与raddr产生-------------------
//-------------------
// GRAYSTYLE2 pointer
//-------------------
   always @(posedge rclk or negedge rrst_n)
   begin
       if (!rrst_n) {rbin, rptr} <= 0;
       else {rbin, rptr} <= {rbinnext, rgraynext};
   end
// Memory read-address pointer (okay to use binary to address memory)
  assign raddr = rbin[ASIZE-1:0];
  assign rbinnext = rbin + (rinc & ~rempty);
  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)
    begin
      if (!rrst_n) rempty <= 1'b1;
      else rempty <= rempty_val;
    end
//---------------wfull产生与waddr产生------------------------------
// 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[ASIZE-1:0];
   assign wbinnext = wbin + (winc & ~wfull);
   assign wgraynext = (wbinnext>>1) ^ wbinnext;
//------------------------------------------------------------------
// Simplified version of the three necessary full-tests:
// assign wfull_val=((wgnext[ADDRSIZE] !=wq2_rptr[ADDRSIZE] ) &&
// (wgnext[ADDRSIZE-1] !=wq2_rptr[ADDRSIZE-1]) &&
// (wgnext[ADDRSIZE-2:0]==wq2_rptr[ADDRSIZE-2:0]));
//------------------------------------------------------------------
   assign wfull_val = (wgraynext=={~wq2_rptr[ASIZE:ASIZE-1],
                       wq2_rptr[ASIZE-2:0]});
  
 always @(posedge wclk or negedge wrst_n)
     if (!wrst_n) wfull <= 1'b0;
     else wfull <= wfull_val;
endmodule

//---------------------STYLE #2-------------------------

module fifo2 (rdata, wfull, rempty, wdata,
winc, wclk, wrst_n, rinc, rclk, rrst_n);
      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] wptr, rptr;
 wire [ASIZE-1:0] waddr, raddr;
 
 async_cmp #(ASIZE) async_cmp(.aempty_n(aempty_n),
                              .afull_n(afull_n),
            .wptr(wptr), .rptr(rptr),
            .wrst_n(wrst_n));
   
  fifomem2 #(DSIZE, ASIZE) fifomem2(.rdata(rdata),
                                    .wdata(wdata),
                                      .waddr(wptr),
              .raddr(rptr),
                                      .wclken(winc),
              .wclk(wclk));
 
  rptr_empty2 #(ASIZE) rptr_empty2(.rempty(rempty),
                                  .rptr(rptr),
                                    .aempty_n(aempty_n),
            .rinc(rinc),
                                    .rclk(rclk),
            .rrst_n(rrst_n));
 
 wptr_full2 #(ASIZE) wptr_full2(.wfull(wfull),
                               .wptr(wptr),
                                 .afull_n(afull_n),
           .winc(winc),
                                 .wclk(wclk),
           .wrst_n(wrst_n));
endmodule

module fifomem2 (rdata, wdata, waddr, raddr, wclken, wclk);
    parameter DATASIZE = 8; // Memory data word width
 parameter ADDRSIZE = 4; // Number of memory address bits
 parameter DEPTH = 1<<ADDRSIZE; // DEPTH = 2**ADDRSIZE
 output [DATASIZE-1:0] rdata;
 input [DATASIZE-1:0] wdata;
 input [ADDRSIZE-1:0] waddr, raddr;
 input wclken, wclk;
`ifdef VENDORRAM
// instantiation of a vendor's dual-port RAM
 VENDOR_RAM MEM (.dout(rdata), .din(wdata),
 .waddr(waddr), .raddr(raddr),
 .wclken(wclken), .clk(wclk));
`else
reg [DATASIZE-1:0] MEM [0:DEPTH-1];
  assign rdata = MEM[raddr];
 always @(posedge wclk)
 if (wclken) MEM[waddr] <= wdata;
`endif
endmodule

module async_cmp (aempty_n, afull_n, wptr, rptr, wrst_n);
    parameter ADDRSIZE = 4;
    parameter N = ADDRSIZE-1;
    output aempty_n, afull_n;
    input [N:0] wptr, rptr;
    input wrst_n;
    reg direction;
    wire high = 1'b1;
    wire dirset_n = ~( (wptr[N]^rptr[N-1]) & ~(wptr[N-1]^rptr[N]));
    wire dirclr_n = ~((~(wptr[N]^rptr[N-1]) & (wptr[N-1]^rptr[N])) |
        ~wrst_n);
  always @(posedge high or negedge dirset_n or negedge dirclr_n)
     if (!dirclr_n) direction <= 1'b0;
     else if (!dirset_n) direction <= 1'b1;
     else direction <= high;
//always @(negedge dirset_n or negedge dirclr_n)
//if (!dirclr_n) direction <= 1'b0;
//else direction <= 1'b1;
  assign aempty_n = ~((wptr == rptr) && !direction);
  assign afull_n = ~((wptr == rptr) && direction);
endmodule

module rptr_empty2 (rempty, rptr, aempty_n, rinc, rclk, rrst_n);
  parameter ADDRSIZE = 4;
  output rempty;
  output [ADDRSIZE-1:0] rptr;
  input aempty_n;
  input rinc, rclk, rrst_n;
  reg [ADDRSIZE-1:0] rptr, rbin;
  reg rempty, rempty2;
  wire [ADDRSIZE-1:0] rgnext, rbnext;
//---------------------------------------------------------------
// GRAYSTYLE2 pointer
//---------------------------------------------------------------
  always @(posedge rclk or negedge rrst_n)
   if (!rrst_n) begin
    rbin <= 0;
    rptr <= 0;
    end
   else begin
    rbin <= rbnext;
    rptr <= rgnext;
    end
//---------------------------------------------------------------
// increment the binary count if not empty
//---------------------------------------------------------------
  assign rbnext = !rempty ? rbin + rinc : rbin;
  assign rgnext = (rbnext>>1) ^ rbnext; // binary-to-gray conversion
  always @(posedge rclk or negedge aempty_n)
   if (!aempty_n) {rempty,rempty2} <= 2'b11;
   else {rempty,rempty2} <= {rempty2,~aempty_n};
endmodule

module wptr_full2 (wfull, wptr, afull_n, winc, wclk, wrst_n);
  parameter ADDRSIZE = 4;
  output wfull;
  output [ADDRSIZE-1:0] wptr;
  input afull_n;
  input winc, wclk, wrst_n;
  reg [ADDRSIZE-1:0] wptr, wbin;
  reg wfull, wfull2;
  wire [ADDRSIZE-1:0] wgnext, wbnext;
//---------------------------------------------------------------
// GRAYSTYLE2 pointer
//---------------------------------------------------------------
always @(posedge wclk or negedge wrst_n)
  if (!wrst_n) begin
   wbin <= 0;
   wptr <= 0;
   end
  else begin
   wbin <= wbnext;
   wptr <= wgnext;
   end
//---------------------------------------------------------------
// increment the binary count if not full
//---------------------------------------------------------------
  assign wbnext = !wfull ? wbin + winc : wbin;
  assign wgnext = (wbnext>>1) ^ wbnext; // binary-to-gray conversion
  always @(posedge wclk or negedge wrst_n or negedge afull_n)
   if (!wrst_n ) {wfull,wfull2} <= 2'b00;
   else if (!afull_n) {wfull,wfull2} <= 2'b11;
   else {wfull,wfull2} <= {wfull2,~afull_n};
endmodule

细心的读者会发现，第一种写法（本人做的修改）把所有信号写在同一个module里，而第二种写法则分了很多模块。哪种写法更好呢？有兴趣的可以想一想，事实上，第二种写法是推荐的写法：原因如下：

异步的多时钟设计应按以下几个原则进行设计：

1，尽可能的将多时钟的逻辑电路（非同步器）分割为多个单时钟的模块，这样有利于静态时序分析工具来进行时序验证。

2，同步器的实现应使得所有输入来自同一个时钟域，而使用另一个时钟域的异步时钟信号采样数据。

3，面向时钟信号的命名方式可以帮助我们确定那些在不同异步时钟域间需要处理的信号。

4，当存在多个跨时钟域的控制信号时，我们必须特别注意这些信号，保证这些控制信号到达新的时钟域仍然能够保持正确的顺序。