254 lines
9.7 KiB
Systemverilog
254 lines
9.7 KiB
Systemverilog
`timescale 1ns/1ps
|
|
module tb_async_sample_fifo;
|
|
localparam integer WIDTH = 96;
|
|
localparam integer ADDR_BITS = 4;
|
|
localparam integer DEPTH = 1 << ADDR_BITS;
|
|
reg arst_n = 1;
|
|
reg wr_clk = 0, rd_clk = 0;
|
|
reg wr_clock_running = 1, rd_clock_running = 1;
|
|
real wr_half_period = 5.0, rd_half_period = 7.1;
|
|
reg wr_valid = 0, rd_ready = 0;
|
|
reg [WIDTH-1:0] wr_data = 0;
|
|
wire wr_ready, wr_overflow, wr_overflow_sticky, rd_valid;
|
|
wire [31:0] wr_overflow_count;
|
|
wire [WIDTH-1:0] rd_data;
|
|
integer writer_mode = 0, reader_mode = 0;
|
|
reg [31:0] wr_random = 32'h87293a11, rd_random = 32'h171395ba;
|
|
reg [63:0] offered_index = 0;
|
|
|
|
// External accepted-word scoreboard; rejected offers never enter it.
|
|
reg [WIDTH-1:0] expected_words [0:32767];
|
|
integer expected_head = 0, expected_tail = 0;
|
|
integer accepted_total = 0, read_total = 0, overflow_total = 0;
|
|
integer stalls_checked = 0, full_cycles = 0;
|
|
reg [31:0] expected_overflows = 0;
|
|
reg expected_overflow_pulse;
|
|
reg previous_stall = 0;
|
|
reg check_burst = 0, burst_started = 0;
|
|
integer burst_reads = 0;
|
|
reg [WIDTH-1:0] stalled_payload;
|
|
integer accepted_before, dropped_before, queued_before_reset;
|
|
|
|
async_sample_fifo #(.WIDTH(WIDTH), .ADDR_BITS(ADDR_BITS)) dut(.*);
|
|
|
|
always begin
|
|
#(wr_half_period);
|
|
if (wr_clock_running) wr_clk = ~wr_clk;
|
|
else wr_clk = 0;
|
|
end
|
|
initial begin
|
|
// Fractional phase avoids coincident monitor edges at the initial rates.
|
|
#1.371;
|
|
forever begin
|
|
#(rd_half_period);
|
|
if (rd_clock_running) rd_clk = ~rd_clk;
|
|
else rd_clk = 0;
|
|
end
|
|
end
|
|
|
|
always @(negedge wr_clk) begin
|
|
wr_random = wr_random * 32'd1664525 + 32'd1013904223;
|
|
wr_valid = arst_n && ((writer_mode == 2) ||
|
|
((writer_mode == 1) && wr_random[31:24] < 8'd190));
|
|
if (wr_valid) begin
|
|
wr_data = {offered_index, (32'ha59c3721 ^ offered_index[31:0])};
|
|
offered_index = offered_index + 1'b1;
|
|
end
|
|
end
|
|
always @(negedge rd_clk) begin
|
|
rd_random = rd_random * 32'd1664525 + 32'd1013904223;
|
|
rd_ready = arst_n && ((reader_mode == 2) ||
|
|
((reader_mode == 1) && rd_random[31:24] < 8'd137));
|
|
end
|
|
|
|
always @(negedge arst_n) begin
|
|
expected_head = 0;
|
|
expected_tail = 0;
|
|
expected_overflows = 0;
|
|
previous_stall = 0;
|
|
end
|
|
|
|
always @(posedge wr_clk) begin
|
|
expected_overflow_pulse = 0;
|
|
if (arst_n) begin
|
|
if (wr_valid && wr_ready) begin
|
|
if (expected_tail >= 32768)
|
|
$fatal(1, "scoreboard capacity exceeded");
|
|
expected_words[expected_tail] = wr_data;
|
|
expected_tail = expected_tail + 1;
|
|
accepted_total = accepted_total + 1;
|
|
end else if (wr_valid && !wr_ready) begin
|
|
// Offers are only enabled after reset-release warmup below.
|
|
expected_overflow_pulse = 1;
|
|
if (expected_overflows != 32'hffffffff)
|
|
expected_overflows = expected_overflows + 1'b1;
|
|
overflow_total = overflow_total + 1;
|
|
end
|
|
if (!wr_ready) full_cycles = full_cycles + 1;
|
|
end
|
|
#0.1;
|
|
if (wr_overflow !== expected_overflow_pulse)
|
|
$fatal(1, "wrong overflow pulse at t=%0t", $time);
|
|
if (wr_overflow_count !== expected_overflows ||
|
|
wr_overflow_sticky !== (expected_overflows != 0))
|
|
$fatal(1, "wrong overflow counter/sticky: got %0d expected %0d at t=%0t",
|
|
wr_overflow_count, expected_overflows, $time);
|
|
end
|
|
|
|
always @(posedge rd_clk) begin
|
|
if (arst_n) begin
|
|
if (check_burst && burst_started && expected_head < expected_tail &&
|
|
!(rd_valid && rd_ready))
|
|
$fatal(1, "bubble in sustained ready/read burst at t=%0t", $time);
|
|
if (check_burst && rd_valid && rd_ready) begin
|
|
burst_started = 1;
|
|
burst_reads = burst_reads + 1;
|
|
end
|
|
if (previous_stall && (rd_valid !== 1'b1 || rd_data !== stalled_payload))
|
|
$fatal(1, "read payload/valid changed through backpressure at t=%0t", $time);
|
|
if (rd_valid && rd_ready) begin
|
|
if (expected_head >= expected_tail)
|
|
$fatal(1, "read from empty scoreboard at t=%0t", $time);
|
|
if (rd_data !== expected_words[expected_head])
|
|
$fatal(1, "read order/data mismatch at %0d: got %h expected %h",
|
|
expected_head, rd_data, expected_words[expected_head]);
|
|
expected_head = expected_head + 1;
|
|
read_total = read_total + 1;
|
|
end
|
|
previous_stall = rd_valid && !rd_ready;
|
|
if (previous_stall) begin
|
|
stalled_payload = rd_data;
|
|
stalls_checked = stalls_checked + 1;
|
|
end
|
|
end
|
|
#0.1;
|
|
if (!arst_n && rd_valid !== 1'b0)
|
|
$fatal(1, "read remained valid during shared reset");
|
|
if (rd_valid) begin
|
|
if (expected_head >= expected_tail || rd_data !== expected_words[expected_head])
|
|
$fatal(1, "prefetched output is stale/out of order at t=%0t", $time);
|
|
end
|
|
end
|
|
|
|
task automatic wait_empty;
|
|
integer attempt;
|
|
begin : drain_wait
|
|
for (attempt = 0; attempt < 1000; attempt = attempt + 1) begin
|
|
@(posedge rd_clk);
|
|
#0.3;
|
|
if (expected_head == expected_tail && rd_valid === 1'b0)
|
|
disable drain_wait;
|
|
end
|
|
$fatal(1, "FIFO failed to drain: pending=%0d", expected_tail - expected_head);
|
|
end
|
|
endtask
|
|
|
|
task automatic stop_writer;
|
|
begin
|
|
writer_mode = 0;
|
|
repeat (3) @(posedge wr_clk);
|
|
#0.3;
|
|
end
|
|
endtask
|
|
|
|
initial begin
|
|
#0.2 arst_n = 0;
|
|
#29.3 arst_n = 1;
|
|
#100;
|
|
if (rd_valid !== 1'b0 || wr_ready !== 1'b1)
|
|
$fatal(1, "incorrect initial empty/ready state");
|
|
|
|
// Stalled reader lets RAM fill; the prefetched output adds one slot.
|
|
writer_mode = 2;
|
|
repeat (80) @(posedge wr_clk);
|
|
#0.3;
|
|
stop_writer();
|
|
if (expected_tail - expected_head != DEPTH + 1 || wr_ready !== 1'b0)
|
|
$fatal(1, "incorrect full capacity: got %0d expected %0d",
|
|
expected_tail - expected_head, DEPTH + 1);
|
|
if (expected_overflows == 0 || rd_valid !== 1'b1)
|
|
$fatal(1, "full/overflow/output-prefetch was not exercised");
|
|
check_burst = 1;
|
|
reader_mode = 2;
|
|
wait_empty();
|
|
check_burst = 0;
|
|
if (burst_reads != DEPTH + 1)
|
|
$fatal(1, "sustained burst did not consume full capacity" );
|
|
repeat (6) @(posedge wr_clk);
|
|
#0.3;
|
|
if (wr_ready !== 1'b1)
|
|
$fatal(1, "full flag failed to clear after drain");
|
|
|
|
// Fast writer, slower reader, randomized gaps and backpressure.
|
|
writer_mode = 1; reader_mode = 1;
|
|
repeat (5000) @(posedge wr_clk);
|
|
#0.233;
|
|
stop_writer();
|
|
reader_mode = 2;
|
|
wait_empty();
|
|
|
|
// Reverse relative clock rates to exercise sustained empty transitions.
|
|
wr_half_period = 8.7; rd_half_period = 3.5;
|
|
writer_mode = 1; reader_mode = 1;
|
|
repeat (3000) @(posedge wr_clk);
|
|
#0.233;
|
|
stop_writer();
|
|
reader_mode = 2;
|
|
wait_empty();
|
|
if (read_total < DEPTH * 100 || stalls_checked < 100)
|
|
$fatal(1, "insufficient wrap/backpressure coverage");
|
|
|
|
// Populate again, pause both clocks, then jointly reset. Valid/ready
|
|
// must drop without an edge, and queued data must be discarded.
|
|
reader_mode = 0;
|
|
repeat (4) @(posedge rd_clk);
|
|
#0.233 writer_mode = 2;
|
|
repeat (80) @(posedge wr_clk);
|
|
#0.233;
|
|
stop_writer();
|
|
queued_before_reset = expected_tail - expected_head;
|
|
if (queued_before_reset != DEPTH + 1)
|
|
$fatal(1, "queued-reset setup did not fill FIFO");
|
|
wr_clock_running = 0; rd_clock_running = 0;
|
|
#40;
|
|
arst_n = 0;
|
|
#3;
|
|
if (rd_valid !== 1'b0 || wr_ready !== 1'b0 || wr_overflow !== 1'b0 ||
|
|
wr_overflow_sticky !== 1'b0 || wr_overflow_count !== 32'd0)
|
|
$fatal(1, "paused-clock shared reset did not clear flags");
|
|
#17 arst_n = 1;
|
|
#80;
|
|
if (rd_valid !== 1'b0 || wr_ready !== 1'b0)
|
|
$fatal(1, "reset released without local clock edges");
|
|
|
|
// Writer may recover first; reader remains reset while its clock is
|
|
// paused. Only the RAM slots are available until read prefetch resumes.
|
|
wr_clock_running = 1;
|
|
repeat (5) @(posedge wr_clk);
|
|
#0.233;
|
|
accepted_before = accepted_total;
|
|
dropped_before = overflow_total;
|
|
writer_mode = 2;
|
|
repeat (80) @(posedge wr_clk);
|
|
#0.233;
|
|
stop_writer();
|
|
if (accepted_total - accepted_before != DEPTH ||
|
|
overflow_total <= dropped_before || rd_valid !== 1'b0)
|
|
$fatal(1, "writer-first recovery/paused-reader capacity failed");
|
|
reader_mode = 2;
|
|
rd_clock_running = 1;
|
|
wait_empty();
|
|
repeat (6) @(posedge wr_clk);
|
|
#0.3;
|
|
if (wr_ready !== 1'b1 || rd_valid !== 1'b0)
|
|
$fatal(1, "incorrect final empty/ready state");
|
|
$display("PASS tb_async_sample_fifo accepted=%0d read=%0d rejected=%0d stalls=%0d discarded_on_reset=%0d",
|
|
accepted_total, read_total, overflow_total, stalls_checked, queued_before_reset);
|
|
$finish;
|
|
end
|
|
initial begin
|
|
#300000;
|
|
$fatal(1, "tb_async_sample_fifo timeout");
|
|
end
|
|
endmodule
|