Files
templates/hdl/scope-acquisition/tests/tb_async_sample_fifo.sv
T

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