【RTL中的FIFO与Buffer的区别】

已于 2024-07-24 11:56:58 修改
阅读量1.1k 收藏 29
点赞数 17
分类专栏： SoC的IP学习 文章标签： fpga开发 硬件架构
于 2024-07-24 11:45:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/biaoxie8050/article/details/140656446
版权

FIFO与Buffer的区别

FIFO的RTL实现

FIFO（先进先出队列）在RTL中通常使用环形缓冲区或双端口存储器来实现。FIFO有两个主要指针：写指针（write pointer）和读指针（read pointer）。写指针指示下一个写入数据的位置，读指针指示下一个读取数据的位置。

使用Verilog实现同步FIFO

简单的同步FIFO实现：

module fifo #(parameter WIDTH = 8, DEPTH = 16)(
    input clk,
    input rst,
    input wr_en,
    input rd_en,
    input [WIDTH-1:0] data_in,
    output reg [WIDTH-1:0] data_out,
    output reg full,
    output reg empty
);
    reg [WIDTH-1:0] fifo_mem [0:DEPTH-1];
    reg [3:0] wr_ptr;
    reg [3:0] rd_ptr;
    reg [4:0] fifo_count;

    always @(posedge clk or posedge rst) begin
        if (rst) begin
            wr_ptr <= 0;
            rd_ptr <= 0;
            fifo_count <= 0;
            full <= 0;
            empty <= 1;
        end else begin
            if (wr_en && !full) begin
                fifo_mem[wr_ptr] <= data_in;
                wr_ptr <= wr_ptr + 1;
                fifo_count <= fifo_count + 1;
            end
            if (rd_en && !empty) begin
                data_out <= fifo_mem[rd_ptr];
                rd_ptr <= rd_ptr + 1;
                fifo_count <= fifo_count - 1;
            end
            full <= (fifo_count == DEPTH);
            empty <= (fifo_count == 0);
        end
    end
endmodule

优点

  • 顺序性：FIFO保证数据以先进先出的顺序处理，适合流式数据处理。
  • 自适应性：可以很容易地适应不同的数据速率，适合异步数据传输。
  • 流量控制：天然支持流量控制机制（反压）。
    缺点：
  • 复杂性：实现较复杂，需要管理读写指针和状态信号（如full和empty）。
  • 资源消耗：对于较大深度的FIFO，存储器资源消耗较大。

使用Verilog实现异步FIFO

异步FIFO（Asynchronous FIFO）需要确保读写指针在不同时钟域之间正确同步。使用格雷码（Gray Code）编码方式可以减少在指针同步过程中出现的亚稳态问题。

module async_fifo #(parameter DATA_WIDTH = 8, ADDR_WIDTH = 4)(
    input wire wr_clk,
    input wire wr_rst,
    input wire wr_en,
    input wire [DATA_WIDTH-1:0] wr_data,
    input wire rd_clk,
    input wire rd_rst,
    input wire rd_en,
    output reg [DATA_WIDTH-1:0] rd_data,
    output wire full,
    output wire empty
);

    // FIFO Memory
    reg [DATA_WIDTH-1:0] fifo_mem [0:(1<<ADDR_WIDTH)-1];

    // Write Pointer and Gray Code
    reg [ADDR_WIDTH:0] wr_ptr_bin, wr_ptr_gray, wr_ptr_gray_sync1, wr_ptr_gray_sync2;
    reg [ADDR_WIDTH:0] rd_ptr_bin, rd_ptr_gray, rd_ptr_gray_sync1, rd_ptr_gray_sync2;

    // Write Pointer Binary to Gray Code Conversion
    always @(posedge wr_clk or posedge wr_rst) begin
        if (wr_rst) begin
            wr_ptr_bin <= 0;
            wr_ptr_gray <= 0;
        end else if (wr_en && !full) begin
            wr_ptr_bin <= wr_ptr_bin + 1;
            wr_ptr_gray <= (wr_ptr_bin + 1) ^ ((wr_ptr_bin + 1) >> 1);
            fifo_mem[wr_ptr_bin[ADDR_WIDTH-1:0]] <= wr_data;
        end
    end

    // Read Pointer Binary to Gray Code Conversion
    always @(posedge rd_clk or posedge rd_rst) begin
        if (rd_rst) begin
            rd_ptr_bin <= 0;
            rd_ptr_gray <= 0;
        end else if (rd_en && !empty) begin
            rd_ptr_bin <= rd_ptr_bin + 1;
            rd_ptr_gray <= (rd_ptr_bin + 1) ^ ((rd_ptr_bin + 1) >> 1);
            rd_data <= fifo_mem[rd_ptr_bin[ADDR_WIDTH-1:0]];
        end
    end

    // Synchronize Write Pointer to Read Clock Domain
    always @(posedge rd_clk or posedge rd_rst) begin
        if (rd_rst) begin
            wr_ptr_gray_sync1 <= 0;
            wr_ptr_gray_sync2 <= 0;
        end else begin
            wr_ptr_gray_sync1 <= wr_ptr_gray;
            wr_ptr_gray_sync2 <= wr_ptr_gray_sync1;
        end
    end

    // Synchronize Read Pointer to Write Clock Domain
    always @(posedge wr_clk or posedge wr_rst) begin
        if (wr_rst) begin
            rd_ptr_gray_sync1 <= 0;
            rd_ptr_gray_sync2 <= 0;
        end else begin
            rd_ptr_gray_sync1 <= rd_ptr_gray;
            rd_ptr_gray_sync2 <= rd_ptr_gray_sync1;
        end
    end

    // Gray Code to Binary Conversion for Write Pointer in Read Clock Domain
    wire [ADDR_WIDTH:0] wr_ptr_bin_sync = gray_to_bin(wr_ptr_gray_sync2);

    // Gray Code to Binary Conversion for Read Pointer in Write Clock Domain
    wire [ADDR_WIDTH:0] rd_ptr_bin_sync = gray_to_bin(rd_ptr_gray_sync2);

    // Full and Empty Flag Generation
    assign full = (wr_ptr_gray == {~rd_ptr_bin_sync[ADDR_WIDTH:ADDR_WIDTH-1], rd_ptr_bin_sync[ADDR_WIDTH-2:0]});
    assign empty = (wr_ptr_gray_sync2 == rd_ptr_gray);

    // Gray Code to Binary Conversion Function
    function [ADDR_WIDTH:0] gray_to_bin;
        input [ADDR_WIDTH:0] gray;
        integer i;
        begin
            gray_to_bin[ADDR_WIDTH] = gray[ADDR_WIDTH];
            for (i = ADDR_WIDTH-1; i >= 0; i = i - 1) begin
                gray_to_bin[i] = gray_to_bin[i+1] ^ gray[i];
            end
        end
    endfunction
endmodule

说明

  1. FIFO Memory：
    使用fifo_mem定义FIFO的存储器阵列。
  2. 写指针和格雷码转换：
  • wr_ptr_bin为写指针的二进制表示。
  • wr_ptr_gray为写指针的格雷码表示。
  • 写入时，写指针按顺序递增，并将数据写入fifo_mem。
  1. 读指针和格雷码转换：
  • rd_ptr_bin为读指针的二进制表示。
  • rd_ptr_gray为读指针的格雷码表示。
  • 读取时，读指针按顺序递增，并从fifo_mem读取数据。
  1. 指针同步：
  • wr_ptr_gray_sync1和wr_ptr_gray_sync2用于将写指针同步到读时钟域。
  • rd_ptr_gray_sync1和rd_ptr_gray_sync2用于将读指针同步到写时钟域。
  1. 灰码到二进制转换：
  • 使用gray_to_bin函数将同步后的格雷码指针转换为二进制表示。
  1. 满和空标志：
  • full标志指示FIFO是否已满。
  • empty标志指示FIFO是否为空。

格雷码与二进制码之间的转换

  • 格雷码到二进制码转换
    格雷码到二进制码的转换基于以下公式：
    B [ n ] = G [ n ] B [ n − 1 ] = B [ n ] ⊕ G [ n − 1 ] … B [ 0 ] = B [ 1 ] ⊕ G [ 0 ] \begin{aligned} B[n] &= G[n] \\ B[n-1] &= B[n] \oplus G[n-1] \\ &\dots \\ B[0] &= B[1] \oplus G[0] \end{aligned} B[n]B[n−1]B[0]​=G[n]=B[n]⊕G[n−1]…=B[1]⊕G[0]​
    其中：
  • 𝐵是二进制码
  • 𝐺是格雷码
  • ⊕表示异或操作

具体来说，从最高位开始，格雷码的最高位直接作为二进制码的最高位。随后，格雷码的每一位与之前计算得到的二进制码的对应位异或，得到当前位的二进制码。

格雷码到二进制码

Verilog代码实现

function [ADDR_WIDTH:0] gray_to_bin;
    input [ADDR_WIDTH:0] gray;
    integer i;
    begin
        gray_to_bin[ADDR_WIDTH] = gray[ADDR_WIDTH]; // Highest bit is the same
        for (i = ADDR_WIDTH-1; i >= 0; i = i - 1) begin
            gray_to_bin[i] = gray_to_bin[i+1] ^ gray[i]; // XOR each bit with the next higher bit
        end
    end
endfunction
  • 二进制码到格雷码转换

二进制码到格雷码的转换基于以下公式：
G [ n ] = B [ n ] G [ n − 1 ] = B [ n ] ⊕ B [ n − 1 ] … G [ 0 ] = B [ 1 ] ⊕ B [ 0 ] \begin{aligned} G[n] &= B[n] \\ G[n-1] &= B[n] \oplus B[n-1] \\ &\dots \\ G[0] &= B[1] \oplus B[0] \end{aligned} G[n]G[n−1]G[0]​=B[n]=B[n]⊕B[n−1]…=B[1]⊕B[0]​
具体来说，从最高位开始，二进制码的最高位直接作为格雷码的最高位。随后，二进制码的每一位与它前一位进行异或，得到当前位的格雷码。
二进制码到格雷码
代码实现
在代码中，写指针和读指针的二进制码转换成格雷码如下：

always @(posedge wr_clk or posedge wr_rst) begin
    if (wr_rst) begin
        wr_ptr_bin <= 0;
        wr_ptr_gray <= 0;
    end else if (wr_en && !full) begin
        wr_ptr_bin <= wr_ptr_bin + 1;
        wr_ptr_gray <= (wr_ptr_bin + 1) ^ ((wr_ptr_bin + 1) >> 1);
        //fifo_mem[wr_ptr_bin[ADDR_WIDTH-1:0]] <= wr_data;
    end
end

always @(posedge rd_clk or posedge rd_rst) begin
    if (rd_rst) begin
        rd_ptr_bin <= 0;
        rd_ptr_gray <= 0;
    end else if (rd_en && !empty) begin
        rd_ptr_bin <= rd_ptr_bin + 1;
        rd_ptr_gray <= (rd_ptr_bin + 1) ^ ((rd_ptr_bin + 1) >> 1);
        //rd_data <= fifo_mem[rd_ptr_bin[ADDR_WIDTH-1:0]];
    end
end

wr_ptr_bin + 1与rd_ptr_bin + 1 表示指针递增之后的新位置，然后我们将这个新位置转换为格雷码，确保指针同步过程中的稳定性。
这个操作确保了在每次写入操作后，指针正确递增并转换为格雷码，用于同步操作。而不直接用当前指针进行格雷码转换，因为我们在更新指针时需要指向下一个位置。

  • 保证指针的递增顺序。
  • 避免同步过程中亚稳态的问题。
  • 符合异步FIFO的设计逻辑，使得读写操作在不同时钟域下能正确运行。

FIFO空满判断逻辑的原理

FIFO的空满状态由读写指针的位置决定。在异步FIFO中，通过将读指针同步到写时钟域、写指针同步到读时钟域，来进行空满状态的判断。

FIFO满判断逻辑

FIFO满的条件是，【写满】在写时钟域，当写指针即将追上读指针，且指针的高位（用于区分周数）不同。具体条件是：
full = ( wr_ptr_gray = = { ∼ rd_ptr_bin_sync [ A D D R _ W I D T H : A D D R _ W I D T H − 1 ] , rd_ptr_bin_sync [ A D D R _ W I D T H − 2 : 0 ] } ) \begin{aligned} \text{full} &= (\text{wr\_ptr\_gray} == \{ \sim \text{rd\_ptr\_bin\_sync}[ADDR\_WIDTH:ADDR\_WIDTH-1], \text{rd\_ptr\_bin\_sync}[ADDR\_WIDTH-2:0] \}) \\ \end{aligned} full​=(wr_ptr_gray=={∼rd_ptr_bin_sync[ADDR_WIDTH:ADDR_WIDTH−1],rd_ptr_bin_sync[ADDR_WIDTH−2:0]})​

FIFO空判断逻辑

FIFO空的条件是，【读空】在读时钟域，当写指针与读指针相等。具体条件是：
empty = ( wr_ptr_gray_sync2 = = rd_ptr_gray ) \begin{aligned} \text{empty} &= (\text{wr\_ptr\_gray\_sync2} == \text{rd\_ptr\_gray}) \\ \end{aligned} empty​=(wr_ptr_gray_sync2==rd_ptr_gray)​

格雷码到二进制码转换：通过将格雷码的最高位直接作为二进制码的最高位，随后逐位进行异或操作完成转换。
二进制码到格雷码转换：通过将二进制码的最高位直接作为格雷码的最高位，随后逐位与前一位进行异或操作完成转换。
FIFO满判断：通过比较写指针的格雷码和读指针的格雷码（同步到写时钟域），判断FIFO是否满。
FIFO空判断：通过比较写指针的格雷码（同步到读时钟域）和读指针的格雷码，判断FIFO是否空。

Buffer的RTL实现

Buffer通常是一个简单的寄存器组或单端口存储器。数据可以按顺序存储，通常没有FIFO那样复杂的控制逻辑。Buffer通常在数据传输中用于临时存储。

使用Verilog实现Buffer

简单的同步Buffer实现：

module buffer #(parameter WIDTH = 8, SIZE = 16)(
    input clk,
    input rst,
    input wr_en,
    input [WIDTH-1:0] data_in,
    output reg [WIDTH-1:0] data_out
);
    reg [WIDTH-1:0] buffer_mem [0:SIZE-1];
    reg [3:0] ptr;

    always @(posedge clk or posedge rst) begin
        if (rst) begin
            ptr <= 0;
        end else if (wr_en) begin
            buffer_mem[ptr] <= data_in;
            ptr <= ptr + 1;
            data_out <= buffer_mem[ptr];
        end
    end
endmodule

优点

  • 简单性：实现简单，控制逻辑相对简单。
  • 低资源消耗：由于控制逻辑简单，资源消耗较少。

缺点

  • 顺序性：没有内建的顺序处理机制，通常需要额外逻辑来管理数据顺序。
  • 流量控制：不支持流量控制，适合用于固定速率的数据流。

FIFO 吸收反压的理论计算

反压时间：
T = D W − R T=\frac{D}{W-R} T=W−RD​

  • T T T是达到FIFO满的时间
  • D D D是FIFO深度
  • W W W是每秒写入的数据量
  • R R R是每秒读取的数据量
    FIFO适合需要顺序处理和流量控制的场景，而Buffer则适合简单的临时存储和固定速率的数据传输。
ICer_yzc
关注
专栏目录
【数字IC验证快速入门】10、Verilog RTL设计必会的FIFO
悟已往之不谏 知来者之可追
07-05 1556
一、同步FIFO FIFO，First In First Out，先入先出的队列。 学会了同步FIFO后，再学习异步FIFO学起来就容易了。 1.1、RAM（Random Access Memory）的设计 设计实现一个16x8的双端口RAM RAM宽度8bit RAM深度16 ADDR位宽2^4，取值范围0~15 对应的代码 module dp_ram(//dp = dual port input wire write_clock, input
【IC前端虚拟项目】inst_buffer子模块DS与RTL编码
最新发布
moon9999的博客
03-01 280
同样的，写完成后进行一样的操作。于是，在代码中维护了四个指针：inst_in_ptr表示指令待写入的位置，inst_cmt_ptr表示待提交指令的位置，rd_done_ptr表示已经读完成位置，wr_done_ptr表示已经写完成。结构的核心部分是一个8项深的cmt_buffer，用于接收、存放和提交指令，同时buffer中还记录着本条指令的状态：读完成、写完成。一般指令的cmt_queue类型结构必然是支持乱序的，不过因为项目里指令本身就是顺序执行的，所以采用顺序更新的结构就可以了。
fifo芯片 matlab,FIFO buffer
weixin_33734921的博客
03-18 275
The dsp.AsyncBuffer System object™ supports reading variable frame sizes from the buffer.Create a dsp.AsyncBuffer System object. The input is white Gaussian noise with a mean of 0, a standard deviatio...
buffer和FIFO的区别
jeason29的专栏
05-18 9931
1.FIFO可以说一块具体的硬件存储设备，也可以说程序在内存中开辟的一段内存区域。而buffer往往就是一段缓冲的数据区域 2.FIFO的数据是先进先出的，而buffer没有这个限制，可以全局访问 3.buffer往往就是一段累积的存储空间，而fifo有时候还可以帮助系统解决时钟域不同步或者数据宽度不一样的情况
记录 队列数据缓冲区（FiFoBuffer）
周小哥的博客
10-10 1367
实际开发中，数据缓存区的概念是必须了解的。如经典的生产、消费模型就是维持着一块数据缓存区供相关的读写操作，当然线程安全问题跑不掉。这里记录下工作中经常使用且经过长时间检验的缓冲区代码，绝大部分场景完全满足，复制直接可用。还有比较经典的环形缓存等设计方法，但很难有万能、全面的方法设计，能兼顾稳定性、简洁性、通用性就是好的设计，取长补短就好。
循环FIFO buffer实现
xinshuwei的博客
08-20 644
/***** circularBuffer.h *****/ #ifndef CIRCULAR_BUFFER_H_ #define CIRCULAR_BUFFER_H_ #define BUFFER_SIZE 128 #define TYPE char // Check if the buffer it is full bool isFull(); // Check if the buffer it is empty bool isEmpty(); // Get the first elemen
【算法】用固定数组实现FIFO buffer
mermaidz的专栏
01-15 809
果然，死的很惨啊，哈哈哈。 【问题】用固定长度的数组实现FIFO buffer，写个lib库。（毛线是lib库？） 事后重新写了一遍，估计还是有问题，但肯定比googleDoc上那个要完善的多。代码如下： bool bufferIsFull = false; bool bufferIsEmpty = false; template class CFifoBuffer { public:
FPGA逻辑设计回顾（6）多比特信号的CDC处理方式之异步FIFO
Reborn Lee
01-15 4521
本文更新了过去对异步FIFO的设计！
(二)异步FIFO
一个粉尘的成长博客
11-18 306
IC设计学习
Hardware ---异步FIFO
Guardian_Bud
11-08 410
一、FIFO简单讲解 1.FIFO的本质是RAM， 先进先出。 2.重要参数：fifo深度（数据量），fifo位宽（数据位宽）。 3.FIFO有同步和异步两种，同步即读写时钟相同，异步即读写时钟不相同，同步FIFO用的少，可以作为数据缓存，异步FIFO可以解决跨时钟域的问题，在应用时需根据实际情况考虑好fifo深度即可。 二、设计要点解析 1、读空信号如何产生？写满信号如何产生？ 读空信号：复位的...
FPGA实验3：DAC FIFO实验
m0_47121112的博客
04-02 1870
1. 实验内容 基于“DDS IP 数字波形合成DAC ” “ ADDA测试” 实验方案 用MMCM 把 合成出100MHz的时钟，让DDS工作在100MHz时钟 让DAC和DAC的接口电路工作在50MHz，此时DAC的采样率为50MHz 在DDS和DAC接口电路之间，放置一个带独立时钟的AXI-Stream-Data FIFO，FIFO两端的时钟分别为DDS的工作时钟100MHz和DAC的工作时钟50MHz 生成FIFO需要带data count信号（本实验仅用于观察，以后的实验中这些信号有用。） DD
吃透Chisel语言.36.Chisel实战之以FIFO为例（一）——FIFO Buffer和Bubble FIFO的Chisel实现
github-3rr0r的博客
08-08 1551
这一部分，我们将以FIFO以及FIFO的各种变体为例，进行Chisel数字设计的实战。这一部分的实战会以小规模的数字设计为例，比如一个FIFO Buffer，它是大规模数字设计中的常用构件块。再比如串行接口（串口），它本身也可以用到FIFO Buffer。这一篇文章就从最基本的FIFO Buffer开始。...
Rtlcompressbuffer 压缩与解压
10-26 1518
#include <iostream> #include <windows.h> using namespace std; //typedef unsigned long NTSTATUS; #define STATUS_SUCCESS ((NTSTATUS)0x00000000UL) #define STATUS_BUFFER_ALL_ZEROS ((NTSTATUS)0x00000117UL) #define STATUS_I.
＜RTL设计的艺术＞ FIFO的正确使用与错误使用讲解
u013613650的博客
07-06 1952
FIFO（先入先出队列）是硬件设计时很常用功能单元，但是RTL bug也经常由它引起。 由FIFO引起bug的原因有多种，主要原因还是没有搞懂为什么需要使用FIFO，本篇主要从根本出发讲解FIFO的作用。 1、FIFO用于消除电路不确定性（推荐） 一般而言，硬件设计出的电路都是确定的电路，但是一些特殊的情况下存在不确定性。例如下面的电路： 电路包含从DDR中读取数据，经过N级pipeline处理后写回到DDR。很明显，其中N级pipeline是确定的电路，但是从DDR读写是不确定的（一般late
异步FIFO RTL代码解读
创芯人--fly的博客
09-28 1193
异步fifo RTL代码解读
C语言下使用ringbuffer实现任意数据类型的FIFO
xmxqiyan的专栏
02-02 6083
头文件 #ifndef __FIFO_H_ #define __FIFO_H_ #pragma pack(4) typedef struct FIFO_Type_STRU { unsigned int Depth; // Fifo深度 volatile unsigned int Head; // Head为起始元素 volatile unsigned int Tail;
同步FIFO分析及rtl代码
10-10 2131
同步FIFO的意思是说FIFO的读写时钟是同一个时钟，因此时钟频率是相同的，只是在相位上可能有差别，不同于异步FIFO，异步FIFO的读写时钟是完全异步的。同步FIFO的对外接口包括时钟，清零，读请求，写请求，数据输入总线，数据输出总线，空以及满信号。下面分别对同步FIFO的对外接口信号作一描述： Ø1．时钟，用于同步FIFO的读和写，上升沿有效。 Ø2．清零，异步...
01 【Verilog实战】同步FIFO的设计（附源码RTL/TB）
热门推荐
毕淑敏曾说过：“我不相信命运，我只相信自己的手；我不相信手掌上的纹路，但我相信手指加上手掌的力量”。在这个快节奏的社会，只有自己能力不足才会被卷，踏踏实实沉下心来学一些技术，及时记录，方便以后复盘。
04-14 1万+
文章目录一、学习内容二、基本概念三、Overview3.1 Function description3.2 Feature list3.3 Block diagram3.4 Interface description3.5 Timing（3）design四、思考和小结（1）思考（2）小结
REALTEK RTL8019AS网卡芯片中文技术手册
RTL8019AS是一款由REALTEK公司生产的网卡芯片，被广泛应用于各种网络设备中。这款芯片的特点包括100引脚的PQFP封装，软件兼容性好，支持即插即用功能，并且能够适应多种网络标准，如10Base5、10Base2、10BaseT。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值