FIFO (первым пришёл — первым вышел) — это память, часто используемая при асинхронной передаче данных. Её особенность в том, что данные обрабатываются по принципу «первым пришёл — первым вышел» (последним пришёл — последним вышел). Фактически проблему асинхронной передачи многоразрядных данных, будь то из быстрого тактового домена в медленный или из медленного в быстрый, можно решить с помощью FIFO.
Принцип работы FIFO
Рабочий процесс
После сброса под управлением тактового сигнала записи и сигналов состояния данные записываются в FIFO. Адрес записи RAM начинается с 0. При каждой записи данных указатель адреса записи увеличивается на единицу, указывая на следующую ячейку памяти. Когда FIFO заполнен, данные больше нельзя записывать; в противном случае данные будут потеряны из-за перезаписи.
Когда данные в FIFO находятся в непустом или полном состоянии, под управлением тактового сигнала чтения и сигналов состояния данные можно считать из FIFO. Адрес чтения RAM начинается с 0. При каждом чтении данных указатель адреса чтения увеличивается на единицу, указывая на следующую ячейку памяти. Когда FIFO пуст при чтении, данные больше нельзя считывать; в противном случае считанные данные будут неверными.
Структура хранения FIFO — это двухпортовая RAM, поэтому чтение и запись могут выполняться одновременно. Типичная структурная схема асинхронного FIFO показана ниже. Порты и внутренние сигналы будут объяснены при написании кода.

Временные диаграммы чтения/записи
Что касается временных диаграмм записи, пока FIFO не заполнен, можно выполнять операции записи; если FIFO заполнен, запись дополнительных данных запрещена.
Что касается временных диаграмм чтения, пока FIFO не пуст, можно выполнять операции чтения; если FIFO пуст, чтение дополнительных данных запрещено.
В любом случае, в период нормального чтения/записи FIFO, если чтение и запись выполняются одновременно, скорость записи в FIFO не должна превышать скорость чтения.
Состояние пустоты при чтении
В начале сброса в FIFO нет данных, и сигнал состояния пустоты активен. После записи данных в FIFO сигнал состояния пустоты переводится в низкий уровень и становится неактивным. Когда адрес чтения данных догоняет адрес записи, то есть когда адреса чтения и записи равны, FIFO находится в состоянии пустоты.
Поскольку это асинхронный FIFO, при сравнении адресов чтения и записи требуется логика синхронизации с использованием регистров, что занимает определенное время. Поэтому сигнал индикации состояния пустоты не обновляется в реальном времени и имеет определенную задержку. Если в течение этого периода задержки в FIFO записываются новые данные, может возникнуть ситуация, когда сигнал индикации состояния пустоты активен, но в FIFO фактически есть данные.
Строго говоря, такая индикация состояния пустоты неверна. Однако цель формирования состояния пустоты — не дать операциям чтения считывать данные из пустого FIFO. Когда формируется сигнал состояния пустоты, в FIFO фактически есть данные, что эквивалентно досрочному определению сигнала состояния пустоты. В этот момент безопасно прекратить чтение данных из FIFO. Поэтому с точки зрения применения такая схема допустима.
Состояние заполненности при записи
В начале сброса в FIFO нет данных, и сигнал заполнения неактивен. После записи данных в FIFO, если операция чтения не выполняется или скорость чтения относительно низкая, сигнал состояния заполнения будет сформирован, как только адрес записи данных превысит адрес чтения данных на одну глубину FIFO. В этот момент адрес записи и адрес чтения также равны, но их смысл различается.

В этом случае часто используется дополнительный 1 бит как бит расширения для адресов чтения и записи соответственно, чтобы различать, пуст ли FIFO или полон, когда адреса чтения и записи совпадают. Когда адреса чтения/записи и биты расширения полностью совпадают, это означает, что объём записанных данных и прочитанных данных равен, и FIFO пуст. Если адреса чтения/записи совпадают, но биты расширения противоположны, это означает, что объём записанных данных превышает объём прочитанных данных на одну глубину FIFO, и FIFO полон. Конечно, предпосылкой для этого условия является то, что состояние пустоты запрещает операции чтения, а состояние полноты запрещает операции записи.
Аналогично, из-за наличия асинхронной логики задержки сигнал состояния полноты не является актуальным в реальном времени. Но это также эквивалентно заблаговременному определению сигнала состояния полноты. В этом случае невыполнение операций записи в FIFO не повлияет на корректность приложения.
Проектирование FIFO
Требования к проектированию
Чтобы спроектировать FIFO, применимый к различным сценариям, предлагаются следующие требования:
- (1) Глубина и ширина FIFO параметризуются, выводятся сигналы состояния пустоты и полноты, а также выводится настраиваемый сигнал состояния полноты. Когда количество внутренних данных в FIFO достигает настроенного значения параметра, переведите этот сигнал в высокий уровень.
- (2) Разрядности входных и выходных данных могут не совпадать, но разрядности записываемых данных и адреса записи должны быть согласованы с разрядностями читаемых данных и адреса чтения. Например, разрядность записываемых данных равна 8 битам, а разрядность адреса записи — 6 битам (64 элемента данных). Если требуется, чтобы разрядность выходных данных была 32 бита, разрядность выходного адреса должна быть 4 бита (16 элементов данных).
- (3) FIFO является асинхронным, то есть сигналы управления чтением и записью поступают из разных тактовых доменов. Перед выводом сигналов состояния «пусто» и «полно» сигналы адреса чтения и записи следует синхронизировать с помощью кода Грея, а ошибки передачи данных при синхронизации с помощью регистровой выборки следует уменьшить за счёт сокращения переключений многоразрядных сигналов. Преобразование между кодом Грея и двоичным кодом показано ниже.
Проектирование двухпортовой RAM
Параметры портов RAM настраиваемые, а разрядности чтения и записи могут не совпадать. Рекомендуется при определении массива памяти брать за основу параметры с большей шириной адреса и меньшей шириной данных, чтобы можно было легко выбирать переменные массива и обращаться к ним.
Описание на Verilog приведено ниже.
Пример
#( parameter AWI = 5 ,
parameter AWO = 7 ,
parameter DWI = 64 ,
parameter DWO = 16
)
(
input CLK_WR , //такт записи
input WR_EN , //разрешение записи
input [AWI-1:0] ADDR_WR ,//адрес записи
input [DWI-1:0] D , //данные для записи
input CLK_RD , //такт чтения
input RD_EN , //разрешение чтения
input [AWO-1:0] ADDR_RD ,//адрес чтения
output reg [DWO-1:0] Q //данные чтения
);
//Ширина выхода больше ширины входа, найти коэффициент расширения и соответствующее количество бит
parameter EXTENT = DWO/DWI ;
parameter EXTENT_BIT = AWI-AWO > 0 ? AWI-AWO : 'b1 ;
//Ширина входа больше ширины выхода, найти коэффициент сокращения и соответствующее количество бит
parameter SHRINK = DWI/DWO ;
parameter SHRINK_BIT = AWO-AWI > 0 ? AWO-AWI : 'b1;
genvar i ;
generate
//Расширение разрядности данных (сокращение разрядности адреса)
if (DWO >= DWI) begin
//Логика записи, запись один раз за такт
reg [DWI-1:0] mem [(1<<AWI)-1 : 0] ;
always @(posedge CLK_WR) begin
if (WR_EN) begin
mem[ADDR_WR] <= D ;
end
end
//Логика чтения, чтение 4 раза за такт
for (i=0; i<EXTENT; i=i+1) begin
always @(posedge CLK_RD) begin
if (RD_EN) begin
Q[(i+1)*DWI-1: i*DWI] <= mem[(ADDR_RD*EXTENT) + i ] ;
end
end
end
end
//=================================================
//Сокращение разрядности данных (расширение разрядности адреса)
else begin
//Логика записи, запись 4 раза за такт
reg [DWO-1:0] mem [(1<<AWO)-1 : 0] ;
for (i=0; i<SHRINK; i=i+1) begin
always @(posedge CLK_WR) begin
if (WR_EN) begin
mem[(ADDR_WR*SHRINK)+i] <= D[(i+1)*DWO -1: i*DWO] ;
end
end
end
//Логика чтения, чтение один раз за такт
always @(posedge CLK_RD) begin
if (RD_EN) begin
Q <= mem[ADDR_RD] ;
end
end
end
endgenerate
endmodule
Проектирование счётчика
Счётчик используется для формирования адресной информации чтения/записи. Его разрядность настраивается. Задавать конечное значение не нужно; просто дайте ему переполниться и автоматически начать счёт заново. Описание на Verilog выглядит следующим образом.
Пример
#(параметр W )
(
input rstn ,
input clk ,
input en ,
output [W-1:0] count
);
reg [W-1:0] count_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
count_r <= 'b0 ;
end
else if (en) begin
count_r <= count_r + 1'b1 ;
end
end
assign count = count_r ;
endmodule
Проектирование FIFO
Этот модуль — основная часть FIFO. Он генерирует логику управления чтением/записью и формирует сигналы состояния empty, full и programmable full.
Из-за ограничений по объёму здесь приведён только код логики для случая, когда ширина данных чтения больше ширины данных записи. Описание кода для случая, когда ширина данных записи больше ширины данных чтения, см. в приложении.
Пример
#( parameter AWI = 5 ,
parameter AWO = 3 ,
parameter DWI = 4 ,
parameter DWO = 16 ,
parameter PROG_DEPTH = 16) //Настраиваемая глубина
(
input rstn, //Один сброс для чтения и записи
input wclk, //тактовый сигнал записи
input winc, //разрешение записи
input [DWI-1: 0] wdata, //данные записи
input rclk, //тактовый сигнал чтения
input rinc, //разрешение чтения
output [DWO-1 : 0] rdata, //данные чтения
output wfull, //флаг заполнения записи
output rempty, //флаг пустоты чтения
output prog_full //флаг программируемого заполнения
);
//Ширина выхода больше ширины входа, найти коэффициент расширения и соответствующее количество бит
parameter EXTENT = DWO/DWI ;
parameter EXTENT_BIT = AWI-AWO ;
//Ширина выходных данных меньше ширины входных данных, найдите коэффициент уменьшения и соответствующее количество бит
parameter SHRINK = DWI/DWO ;
parameter SHRINK_BIT = AWO-AWI ;
//==================== счетчик push/wr ===============
wire [AWI-1:0] waddr ;
wire wover_flag ; //Использовать один дополнительный бит для расширения адреса записи
ccnt #(.W(AWI+1))
u_push_cnt(
.rstn (rstn),
.clk (wclk),
.en (winc && !wfull), //Запретить запись, когда заполнено
.count ({wover_flag, waddr})
);
//============== счетчик pop/rd ===================
wire [AWO-1:0] raddr ;
wire rover_flag ; //Использовать один дополнительный бит для расширения адреса чтения
ccnt #(.W(AWO+1))
u_pop_cnt(
.rstn (rstn),
.clk (rclk),
.en (rinc & !rempty), //Запретить чтение, когда пусто
.count ({rover_flag, raddr})
);
//==============================================
//Узкие данные на входе, широкие данные на выходе
generate
if (DWO >= DWI) begin : EXTENT_WIDTH
//Преобразование кода Грея
wire [AWI:0] wptr = ({wover_flag, waddr}>>1) ^ ({wover_flag, waddr}) ;
//Синхронизировать указатель записи данных с доменом тактового сигнала чтения
reg [AWI:0] rq2_wptr_r0 ;
reg [AWI:0] rq2_wptr_r1 ;
always @(posedge rclk or negedge rstn) begin
if (!rstn) begin
rq2_wptr_r0 <= 'b0 ;
rq2_wptr_r1 <= 'b0 ;
end
else begin
rq2_wptr_r0 <= wptr ;
rq2_wptr_r1 <= rq2_wptr_r0 ;
end
end
//Преобразование кода Грея
wire [AWI-1:0] raddr_ex = raddr << EXTENT_BIT ;
wire [AWI:0] rptr = ({rover_flag, raddr_ex}>>1) ^ ({rover_flag, raddr_ex}) ;
//Синхронизировать указатель чтения данных с тактовым доменом записи
reg [AWI:0] wq2_rptr_r0 ;
reg [AWI:0] wq2_rptr_r1 ;
always @(posedge wclk or negedge rstn) begin
if (!rstn) begin
wq2_rptr_r0 <= 'b0 ;
wq2_rptr_r1 <= 'b0 ;
end
else begin
wq2_rptr_r0 <= rptr ;
wq2_rptr_r1 <= wq2_rptr_r0 ;
end
end
//Обратное преобразование кода Грея
//Если нужны только сигналы состояния пустоты и полного заполнения, обратное преобразование не требуется
//Поскольку есть программируемый сигнал полного состояния, обратное преобразование адреса удобно для сравнения
reg [AWI:0] wq2_rptr_decode ;
reg [AWI:0] rq2_wptr_decode ;
целое число i ;
always @(*) begin
wq2_rptr_decode[AWI] = wq2_rptr_r1[AWI];
for (i=AWI-1; i>=0; i=i-1) begin
wq2_rptr_decode[i] = wq2_rptr_decode[i+1] ^ wq2_rptr_r1[i] ;
end
end
always @(*) begin
rq2_wptr_decode[AWI] = rq2_wptr_r1[AWI];
for (i=AWI-1; i>=0; i=i-1) begin
rq2_wptr_decode[i] = rq2_wptr_decode[i+1] ^ rq2_wptr_r1[i] ;
end
end
//Когда адреса чтения/записи и биты расширения полностью совпадают, это пустое состояние
assign rempty = (rover_flag == rq2_wptr_decode[AWI]) &&
(raddr_ex >= rq2_wptr_decode[AWI-1:0]);
//Когда адреса чтения/записи совпадают, но биты расширения различаются, это полное состояние
assign wfull = (wover_flag != wq2_rptr_decode[AWI]) &&
(waddr >= wq2_rptr_decode[AWI-1:0]) ;
//Когда биты расширения совпадают, адрес записи обязательно не меньше адреса чтения
//Когда биты расширения различаются, часть адреса записи обязательно меньше адреса чтения; к фактическому адресу записи нужно добавить одну глубину FIFO
assign prog_full = (wover_flag == wq2_rptr_decode[AWI]) ?
waddr - wq2_rptr_decode[AWI-1:0] >= PROG_DEPTH-1 :
waddr + (1<<AWI) - wq2_rptr_decode[AWI-1:0] >= PROG_DEPTH-1;
//Создание экземпляра двухпортовой RAM
ramdp
#( .AWI (AWI),
.AWO (AWO),
.DWI (DWI),
.DWO (DWO))
u_ramdp
(
.CLK_WR (wclk),
.WR_EN (winc & !wfull), //Запретить запись, когда буфер заполнен
.ADDR_WR (waddr),
.D (wdata[DWI-1:0]),
.CLK_RD (rclk),
.RD_EN (rinc & !rempty), //Запретить чтение, когда пусто
.ADDR_RD (raddr),
.Q (rdata[DWO-1:0])
);
end
//==============================================
//широкий вход и узкий выход
/*
else begin: SHRINK_WIDTH
……
end
*/
endgenerate
endmodule
Инстанцирование FIFO
Разработанный FIFO можно инстанцировать ниже для выполнения асинхронной обработки передачи данных разрядностью в несколько бит.
Разрядность записываемых данных — 4 бита, а глубина записи — 32.
Разрядность считываемых данных — 16 бит, глубина чтения — 8, а настраиваемая полная глубина — 16.
Пример
input rstn,
input [4-1: 0] din, //Асинхронные данные записи
input din_clk, //Асинхронный тактовый сигнал записи
input din_en, //асинхронное разрешение записи
output [16-1 : 0] dout, //данные после синхронизации
input dout_clk, // Использовать тактовый сигнал синхронно
input dout_en ); // Синхронное разрешение данных
wire fifo_empty, fifo_full, prog_full ;
wire rd_en_wir ;
wire [15:0] dout_wir ;
// Запретить чтение в состоянии «пусто для чтения», иначе чтение будет продолжаться
assign rd_en_wir = fifo_empty ? 1'b0 : 1'b1 ;
fifo #(.AWI(5), .AWO(3), .DWI(4), .DWO(16), .PROG_DEPTH(16))
u_buf_s2b(
.rstn (rstn),
.wclk (din_clk),
.winc (din_en),
.wdata (din),
.rclk (dout_clk),
.rinc (rd_en_wir),
.rdata (dout_wir),
.wfull (fifo_full),
.rempty (fifo_empty),
.prog_full (prog_full));
// Данные и разрешение после синхронизации кэша
reg dout_en_r ;
always @(posedge dout_clk or negedge rstn) begin
if (!rstn) begin
dout_en_r <= 1'b0 ;
end
else begin
dout_en_r <= rd_en_wir ;
end
end
assign dout = dout_wir ;
assign dout_en = dout_en_r ;
endmodule
testbench
Пример
`define SMALL2BIG
module test ;
`ifdef SMALL2BIG
reg rstn ;
reg clk_slow, clk_fast ;
reg [3:0] din ;
reg din_en ;
wire [15:0] dout ;
wire dout_en ;
//сброс
initial begin
clk_slow = 0 ;
clk_fast = 0 ;
rstn = 0 ;
#50 rstn = 1 ;
end
// Тактовый сигнал чтения clock_slow быстрее, чем 1/4 тактового сигнала записи clk_fast
// Убедитесь, что данные чтения немного быстрее данных записи
parameter CYCLE_WR = 40 ;
always #(CYCLE_WR/2/4) clk_fast = ~clk_fast ;
always #(CYCLE_WR/2-1) clk_slow = ~clk_slow ;
// генерация данных
initial begin
din = 16'h4321 ;
din_en = 0 ;
wait (rstn) ;
//(1) Проверка сигналов full, prog_full, empty
force test.u_data_buf2.u_buf_s2b.rinc = 1'b0 ;
repeat(32) begin
@(negedge clk_fast) ;
din_en = 1'b1 ;
din = {$random()} % 16;
end
@(negedge clk_fast) din_en = 1'b0 ;
//(2) Проверка чтения/записи данных
#500 ;
rstn = 0 ;
#10 rstn = 1 ;
release test.u_data_buf2.u_buf_s2b.rinc;
repeat(100) begin
@(negedge clk_fast) ;
din_en = 1'b1 ;
din = {$random()} % 16;
end
//(3) Остановить чтение и снова проверить сигналы empyt, full, prog_full
force test.u_data_buf2.u_buf_s2b.rinc = 1'b0 ;
repeat(18) begin
@(negedge clk_fast) ;
din_en = 1'b1 ;
din = {$random()} % 16;
end
end
fifo_s2b u_data_buf2(
.rstn (rstn),
.din (din),
.din_clk (clk_fast),
.din_en (din_en),
.dout (dout),
.dout_clk (clk_slow),
.dout_en (dout_en));
`else
`endif
//остановить моделирование
initial begin
forever begin
#100;
if ($time >= 5000) $finish ;
end
end
endmodule
Анализ моделирования
На основе 3-шагового тестового воздействия в тестбенче анализ выглядит следующим образом:
Тест (1): Результаты временного анализа порта FIFO и некоторых внутренних сигналов приведены ниже.
Как видно из рисунка, перед тем как FIFO внутренне начинает записывать данные и сигнал состояния пустоты переходит в низкий уровень, есть период задержки. Это вызвано синхронизацией информации об адресах чтения/записи.
Поскольку в это время операция чтения из FIFO не выполняется, задержка перехода сигналов full и prog_full в высокий уровень относительно операции записи данных практически отсутствует.

Тест (2): Когда FIFO одновременно выполняет чтение и запись, портовые сигналы цифрового модуля верхнего уровня асинхронной обработки показаны ниже. Два рисунка соответственно показывают процесс чтения в начале и в конце передачи данных.
Как видно из рисунков, данные корректно передаются как в начале, так и в конце, что завершает асинхронную обработку данных различной разрядности между разными тактовыми доменами.


Тест (3): Временная диаграмма моделирования всего поведения чтения/записи FIFO и остановки чтения показана ниже.
Как видно из рисунка, когда чтение и запись выполняются одновременно, сигнал состояния пустоты чтения rempty переходит в низкий уровень, что указывает на запись данных в FIFO. С одной стороны, скорость чтения данных немного выше скорости записи, и между передачами данных есть задержка, поэтому rempty будет переходить в высокий уровень в промежуточном процессе.
Во время процесса чтения/записи сигналы full и prog_full остаются на низком уровне, что указывает на то, что объем данных в FIFO не достиг определенного уровня. После остановки операции чтения два сигнала full вскоре переходят в высокий уровень, что указывает на заполнение FIFO. При внимательном сравнении информации об адресах чтения/записи поведение FIFO не вызывает проблем.

Полная реализация FIFO представлена во вложении, включая асинхронную реализацию и моделирование для случаев, когда разрядность входных данных меньше разрядности выходных данных.
Скачать исходный код для этой главы
Скачать