micheleandClaude Sonnet 5
fa327b75ca
New ddr_prefetch_mgr.v wraps act_tile_fetch.v with a depth-2 ping-pong buffer, issuing the next tile's DDR3 fetch as soon as the fetch engine is free instead of waiting for packed_slot.v to finish consuming the current tile. Wired into packed_slot.v's tile loop (job-level start instead of per-tile req), simplifying the S_TILEWAIT join in the process (ddrpf_tile_valid is level-held, no separate act_seen latch needed). Verification: new tb_ddr_prefetch_mgr.v (25/25 PASS after fixing a real testbench polling race found via iteration-tagged tracing, not an RTL bug), tb_packed_slot.v re-run unmodified (9/9 PASS, bit-identical results), tb_n2_system_ddr3.v re-run via real xsim against real ddr3_model.sv (8/8 PASS). Real P&R: WNS +0.073ns (up from EXP-0082's +0.068ns), LUTs 5644, DSP48E1 16 unchanged, 0 failing endpoints. Honest result: real A/B on the actual DDR3 backend (same testbench, before/after) shows a real but modest 2.86% reduction in total simulated time - smaller than the original hypothesis suggested, because neural_processor_packed.v already accepts one operand per cycle, so the per-tile dead time being removed was already small relative to real DDR3 fetch latency. Docs updated to report this honestly rather than oversell it; the larger multi-slot DDRManager is deferred pending re-measurement against the (still pending, user-gated) 32-bit channel widening. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01MUG92aM9m68TRc4rG55BcC
311 lines
15 KiB
Verilog
311 lines
15 KiB
Verilog
`timescale 1ns/1ps
|
|
|
|
// ============================================================
|
|
// EXP-0083: (1) isolated correctness test for ddr_prefetch_mgr.v --
|
|
// same real SDR SDRAM placeholder backend precedent as
|
|
// tb_act_tile_fetch.v -- and (2) a real, measured, honest A/B cycle-
|
|
// count comparison against the OLD per-tile req/wait/consume loop
|
|
// packed_slot.v used before EXP-0083, to get a REAL number for the
|
|
// look-ahead prefetch's benefit instead of asserting one.
|
|
//
|
|
// Both the "baseline" (direct act_tile_fetch.v, one requester per
|
|
// tile, old packed_slot.v sequencing) and the "prefetch" (ddr_
|
|
// prefetch_mgr.v, EXP-0083) loops are run against the SAME shared
|
|
// backend and the SAME preloaded data, back to back, muxed the same
|
|
// way tb_act_tile_fetch.v's own pre_active mux works -- so the
|
|
// comparison is apples to apples, not two different simulated
|
|
// environments.
|
|
//
|
|
// Both loops apply the SAME 2-cycle "simulated compute overhead" per
|
|
// tile (matching packed_slot.v's own real S_TILEREQ + S_OPERAND
|
|
// single-cycle costs) between a tile becoming available and the next
|
|
// step being taken -- the honest question this answers is: does
|
|
// removing the OLD design's serialization of that overhead with the
|
|
// NEXT tile's DDR3 fetch produce a real, measurable improvement, and
|
|
// how much.
|
|
// ============================================================
|
|
module tb;
|
|
localparam BURST_LEN = 8;
|
|
localparam ROW_BITS = 13;
|
|
localparam COL_BITS = 10;
|
|
localparam BANK_BITS = 2;
|
|
localparam ADDR_WIDTH = BANK_BITS + ROW_BITS + COL_BITS; // 25
|
|
localparam CLK_FREQ_MHZ = 64;
|
|
localparam CLK_PERIOD_NS = 1000.0/CLK_FREQ_MHZ;
|
|
localparam DATA_WIDTH = 8;
|
|
localparam P_IN = 8;
|
|
localparam N_TILES = 6; // 3 burst-pairs/lane -- enough to see steady-state behavior
|
|
|
|
reg clk = 0;
|
|
always #(CLK_PERIOD_NS/2.0) clk = ~clk;
|
|
reg rst;
|
|
|
|
wire ctrl_req, ctrl_wr;
|
|
wire [ADDR_WIDTH-1:0] ctrl_addr;
|
|
wire [16*BURST_LEN-1:0] ctrl_wdata, ctrl_rdata;
|
|
wire [2*BURST_LEN-1:0] ctrl_wmask;
|
|
wire ctrl_ready, ctrl_busy;
|
|
wire cke, cs_n, ras_n, cas_n, we_n;
|
|
wire [BANK_BITS-1:0] ba;
|
|
wire [ROW_BITS-1:0] a;
|
|
wire [15:0] dq;
|
|
wire [1:0] dqm;
|
|
|
|
sdram_controller #(
|
|
.CLK_FREQ_MHZ(CLK_FREQ_MHZ), .BURST_LEN(BURST_LEN),
|
|
.ROW_BITS(ROW_BITS), .COL_BITS(COL_BITS), .BANK_BITS(BANK_BITS)
|
|
) u_ctrl (
|
|
.clk(clk), .rst(rst),
|
|
.req(ctrl_req), .wr(ctrl_wr), .addr(ctrl_addr), .wdata(ctrl_wdata), .wmask(ctrl_wmask),
|
|
.rdata(ctrl_rdata), .ready(ctrl_ready), .busy(ctrl_busy),
|
|
.sdram_cke(cke), .sdram_cs_n(cs_n), .sdram_ras_n(ras_n), .sdram_cas_n(cas_n), .sdram_we_n(we_n),
|
|
.sdram_ba(ba), .sdram_a(a), .sdram_dq(dq), .sdram_dqm(dqm)
|
|
);
|
|
sdram_model #(
|
|
.CLK_FREQ_MHZ(CLK_FREQ_MHZ), .ROW_BITS(ROW_BITS), .COL_BITS(COL_BITS), .BANK_BITS(BANK_BITS)
|
|
) u_mem (
|
|
.clk(clk), .cke(cke), .cs_n(cs_n), .ras_n(ras_n), .cas_n(cas_n), .we_n(we_n),
|
|
.ba(ba), .a(a), .dq(dq), .dqm(dqm)
|
|
);
|
|
|
|
// ---- 3-way mux on the shared backend: preload / baseline DUT / prefetch DUT ----
|
|
localparam SEL_PRELOAD = 2'd0, SEL_BASE = 2'd1, SEL_PF = 2'd2;
|
|
reg [1:0] sel;
|
|
|
|
reg pre_req, pre_wr;
|
|
reg [ADDR_WIDTH-1:0] pre_addr;
|
|
reg [16*BURST_LEN-1:0] pre_wdata;
|
|
|
|
// ---- baseline DUT: plain act_tile_fetch.v, driven by a per-tile
|
|
// req/wait/consume loop replicating OLD packed_slot.v sequencing ----
|
|
reg base_req;
|
|
reg [ADDR_WIDTH-1:0] base_base_a, base_base_b;
|
|
reg [15:0] base_tcnt;
|
|
wire base_valid;
|
|
wire signed [DATA_WIDTH*P_IN-1:0] base_data_a, base_data_b;
|
|
wire base_mem_active;
|
|
wire base_ctrl_req, base_ctrl_wr;
|
|
wire [ADDR_WIDTH-1:0] base_ctrl_addr;
|
|
wire [16*BURST_LEN-1:0] base_ctrl_wdata;
|
|
wire [2*BURST_LEN-1:0] base_ctrl_wmask;
|
|
|
|
act_tile_fetch #(
|
|
.DATA_WIDTH(DATA_WIDTH), .P_IN(P_IN), .BURST_LEN(BURST_LEN), .ADDR_WIDTH(ADDR_WIDTH)
|
|
) u_base (
|
|
.clk(clk), .rst(rst),
|
|
.req(base_req), .base_a(base_base_a), .base_b(base_base_b), .tcnt(base_tcnt),
|
|
.valid(base_valid), .data_a(base_data_a), .data_b(base_data_b),
|
|
.mem_active(base_mem_active), .mem_grant(sel == SEL_BASE),
|
|
.ctrl_req(base_ctrl_req), .ctrl_wr(base_ctrl_wr), .ctrl_addr(base_ctrl_addr),
|
|
.ctrl_wdata(base_ctrl_wdata), .ctrl_wmask(base_ctrl_wmask),
|
|
.ctrl_rdata(ctrl_rdata), .ctrl_ready(ctrl_ready), .ctrl_busy(ctrl_busy)
|
|
);
|
|
|
|
// ---- prefetch DUT: ddr_prefetch_mgr.v (EXP-0083) ----
|
|
reg pf_job_start;
|
|
reg [ADDR_WIDTH-1:0] pf_base_a, pf_base_b;
|
|
reg [15:0] pf_n_tiles;
|
|
wire pf_tile_valid;
|
|
wire signed [DATA_WIDTH*P_IN-1:0] pf_data_a, pf_data_b;
|
|
reg pf_tile_consume;
|
|
wire pf_mem_active;
|
|
wire pf_ctrl_req, pf_ctrl_wr;
|
|
wire [ADDR_WIDTH-1:0] pf_ctrl_addr;
|
|
wire [16*BURST_LEN-1:0] pf_ctrl_wdata;
|
|
wire [2*BURST_LEN-1:0] pf_ctrl_wmask;
|
|
|
|
ddr_prefetch_mgr #(
|
|
.DATA_WIDTH(DATA_WIDTH), .P_IN(P_IN), .BURST_LEN(BURST_LEN), .ADDR_WIDTH(ADDR_WIDTH)
|
|
) u_pf (
|
|
.clk(clk), .rst(rst),
|
|
.job_start(pf_job_start), .base_a(pf_base_a), .base_b(pf_base_b), .n_tiles(pf_n_tiles),
|
|
.tile_valid(pf_tile_valid), .data_a(pf_data_a), .data_b(pf_data_b), .tile_consume(pf_tile_consume),
|
|
.mem_active(pf_mem_active), .mem_grant(sel == SEL_PF),
|
|
.ctrl_req(pf_ctrl_req), .ctrl_wr(pf_ctrl_wr), .ctrl_addr(pf_ctrl_addr),
|
|
.ctrl_wdata(pf_ctrl_wdata), .ctrl_wmask(pf_ctrl_wmask),
|
|
.ctrl_rdata(ctrl_rdata), .ctrl_ready(ctrl_ready), .ctrl_busy(ctrl_busy)
|
|
);
|
|
|
|
assign ctrl_req = (sel==SEL_PRELOAD) ? pre_req : (sel==SEL_BASE) ? base_ctrl_req : pf_ctrl_req;
|
|
assign ctrl_wr = (sel==SEL_PRELOAD) ? pre_wr : (sel==SEL_BASE) ? base_ctrl_wr : pf_ctrl_wr;
|
|
assign ctrl_addr = (sel==SEL_PRELOAD) ? pre_addr : (sel==SEL_BASE) ? base_ctrl_addr : pf_ctrl_addr;
|
|
assign ctrl_wdata = (sel==SEL_PRELOAD) ? pre_wdata : (sel==SEL_BASE) ? base_ctrl_wdata : pf_ctrl_wdata;
|
|
assign ctrl_wmask = (sel==SEL_BASE) ? base_ctrl_wmask : (sel==SEL_PF) ? pf_ctrl_wmask : {(2*BURST_LEN){1'b0}};
|
|
|
|
task automatic sdram_write_burst(input [ADDR_WIDTH-1:0] word_addr, input [16*BURST_LEN-1:0] data);
|
|
begin
|
|
@(posedge clk); while (ctrl_busy) @(posedge clk);
|
|
pre_req = 1'b1; pre_wr = 1'b1; pre_addr = word_addr; pre_wdata = data;
|
|
@(posedge clk); pre_req = 1'b0;
|
|
while (!ctrl_ready) @(posedge clk);
|
|
end
|
|
endtask
|
|
|
|
function automatic signed [7:0] act_byte(input integer base, input integer t, input integer k);
|
|
act_byte = $signed(8'((base*13 + t*31 + k*7 + 5) & 8'hFF));
|
|
endfunction
|
|
|
|
integer errors, tests;
|
|
task automatic check(input cond, input [255:0] name);
|
|
begin
|
|
tests = tests + 1;
|
|
if (!cond) begin errors = errors + 1; $display("FAIL: %0s", name); end
|
|
else $display("PASS: %0s", name);
|
|
end
|
|
endtask
|
|
|
|
reg signed [DATA_WIDTH*P_IN-1:0] exp_a, exp_b;
|
|
integer k, wi, cyc;
|
|
reg [16*BURST_LEN-1:0] burst;
|
|
integer t_start, t_end, base_cycles, pf_cycles;
|
|
|
|
initial begin
|
|
errors = 0; tests = 0;
|
|
rst = 1; sel = SEL_PRELOAD;
|
|
pre_req = 0; pre_wr = 0; pre_addr = 0; pre_wdata = 0;
|
|
base_req = 0; base_base_a = 0; base_base_b = 0; base_tcnt = 0;
|
|
pf_job_start = 0; pf_base_a = 0; pf_base_b = 0; pf_n_tiles = 0; pf_tile_consume = 0;
|
|
repeat(5) @(posedge clk);
|
|
rst = 0;
|
|
@(posedge clk); while (ctrl_busy) @(posedge clk);
|
|
|
|
$display("=== preload lane A base=0, lane B base=200, %0d tiles (EXP-0081 2-tiles/burst layout) ===", N_TILES);
|
|
for (wi = 0; wi < N_TILES/2; wi = wi + 1) begin
|
|
for (k = 0; k < P_IN/2; k = k + 1)
|
|
burst[k*16 +: 16] = {act_byte(0, 2*wi, 2*k+1), act_byte(0, 2*wi, 2*k)};
|
|
for (k = 0; k < P_IN/2; k = k + 1)
|
|
burst[(P_IN/2+k)*16 +: 16] = {act_byte(0, 2*wi+1, 2*k+1), act_byte(0, 2*wi+1, 2*k)};
|
|
sdram_write_burst(0 + wi*BURST_LEN, burst);
|
|
|
|
for (k = 0; k < P_IN/2; k = k + 1)
|
|
burst[k*16 +: 16] = {act_byte(200, 2*wi, 2*k+1), act_byte(200, 2*wi, 2*k)};
|
|
for (k = 0; k < P_IN/2; k = k + 1)
|
|
burst[(P_IN/2+k)*16 +: 16] = {act_byte(200, 2*wi+1, 2*k+1), act_byte(200, 2*wi+1, 2*k)};
|
|
sdram_write_burst(200 + wi*BURST_LEN, burst);
|
|
end
|
|
@(posedge clk);
|
|
|
|
// ============================================================
|
|
// PART 1: baseline correctness + real cycle count, OLD-style
|
|
// per-tile req -> wait valid -> 2-cycle simulated compute -> next req
|
|
// ============================================================
|
|
$display("=== PART 1: baseline (direct act_tile_fetch.v, old packed_slot.v loop) ===");
|
|
sel = SEL_BASE;
|
|
@(posedge clk);
|
|
t_start = $time;
|
|
for (k = 0; k < N_TILES; k = k + 1) begin
|
|
@(posedge clk);
|
|
base_base_a <= 0; base_base_b <= 200; base_tcnt <= k[15:0];
|
|
base_req <= 1'b1;
|
|
@(posedge clk);
|
|
base_req <= 1'b0;
|
|
while (!base_valid) @(posedge clk);
|
|
for (wi = 0; wi < P_IN; wi = wi + 1) begin
|
|
exp_a[wi*DATA_WIDTH +: DATA_WIDTH] = act_byte(0, k, wi);
|
|
exp_b[wi*DATA_WIDTH +: DATA_WIDTH] = act_byte(200, k, wi);
|
|
end
|
|
check(base_data_a === exp_a, "baseline: lane A bit-exact");
|
|
check(base_data_b === exp_b, "baseline: lane B bit-exact");
|
|
repeat(2) @(posedge clk); // simulated S_TILEREQ + S_OPERAND overhead
|
|
end
|
|
t_end = $time;
|
|
base_cycles = (t_end - t_start) / CLK_PERIOD_NS;
|
|
$display("baseline: %0d tiles in %0d cycles (%0.2f cycles/tile)", N_TILES, base_cycles, base_cycles*1.0/N_TILES);
|
|
|
|
// ============================================================
|
|
// PART 2: prefetch correctness + real cycle count, EXP-0083
|
|
// job-level start, poll tile_valid, 2-cycle simulated compute, consume
|
|
// ============================================================
|
|
$display("=== PART 2: prefetch (ddr_prefetch_mgr.v, EXP-0083) ===");
|
|
sel = SEL_PF;
|
|
@(posedge clk);
|
|
pf_base_a <= 0; pf_base_b <= 200; pf_n_tiles <= N_TILES[15:0];
|
|
pf_job_start <= 1'b1;
|
|
t_start = $time;
|
|
@(posedge clk);
|
|
pf_job_start <= 1'b0;
|
|
for (k = 0; k < N_TILES; k = k + 1) begin
|
|
// #1 settle delay: without it, this check can run in the same
|
|
// simulation delta as the PREVIOUS iteration's tile_consume
|
|
// pulse being sampled by the DUT (both triggered off the same
|
|
// @(posedge clk)), reading pf_tile_valid/bank_valid BEFORE the
|
|
// DUT's own nonblocking update for that consume has been
|
|
// applied -- a real testbench race, not an RTL bug (found via
|
|
// an iteration-tagged trace: k=1 was reading k=0's still-
|
|
// unconsumed bank). #1 (real time, 1ns << the 15.625ns clock
|
|
// period) forces this poll to always run strictly after that
|
|
// update has settled.
|
|
#1;
|
|
while (!pf_tile_valid) @(posedge clk);
|
|
for (wi = 0; wi < P_IN; wi = wi + 1) begin
|
|
exp_a[wi*DATA_WIDTH +: DATA_WIDTH] = act_byte(0, k, wi);
|
|
exp_b[wi*DATA_WIDTH +: DATA_WIDTH] = act_byte(200, k, wi);
|
|
end
|
|
check(pf_data_a === exp_a, "prefetch: lane A bit-exact");
|
|
check(pf_data_b === exp_b, "prefetch: lane B bit-exact");
|
|
repeat(2) @(posedge clk); // SAME simulated compute overhead as baseline
|
|
pf_tile_consume <= 1'b1;
|
|
@(posedge clk);
|
|
pf_tile_consume <= 1'b0;
|
|
end
|
|
t_end = $time;
|
|
pf_cycles = (t_end - t_start) / CLK_PERIOD_NS;
|
|
$display("prefetch: %0d tiles in %0d cycles (%0.2f cycles/tile)", N_TILES, pf_cycles, pf_cycles*1.0/N_TILES);
|
|
|
|
$display("=== REAL MEASURED COMPARISON (row-switch-heavy, 3 different burst pairs): baseline=%0d cycles, prefetch=%0d cycles, reduction=%0.1f%% ===",
|
|
base_cycles, pf_cycles, 100.0*(base_cycles-pf_cycles)/base_cycles);
|
|
check(pf_cycles < base_cycles, "prefetch is real, measurably faster than baseline (row-switch-heavy)");
|
|
|
|
// ============================================================
|
|
// PART 3 (EXP-0083 addendum): best-case, SAME-ROW comparison --
|
|
// only tiles 0/1 (both already resident in the FIRST preloaded
|
|
// burst pair, no row activation needed for either), isolating
|
|
// the look-ahead benefit from row-switch cost entirely. Answers
|
|
// honestly whether the small PART-1/2 result is because the
|
|
// benefit is inherently small, or because row-switch cost
|
|
// dominates and masks it in that scenario.
|
|
// ============================================================
|
|
$display("=== PART 3: same-row best case (2 tiles, single burst pair, no row switch) ===");
|
|
sel = SEL_BASE;
|
|
@(posedge clk);
|
|
t_start = $time;
|
|
for (k = 0; k < 2; k = k + 1) begin
|
|
@(posedge clk);
|
|
base_base_a <= 0; base_base_b <= 200; base_tcnt <= k[15:0];
|
|
base_req <= 1'b1;
|
|
@(posedge clk);
|
|
base_req <= 1'b0;
|
|
while (!base_valid) @(posedge clk);
|
|
repeat(2) @(posedge clk);
|
|
end
|
|
t_end = $time;
|
|
base_cycles = (t_end - t_start) / CLK_PERIOD_NS;
|
|
$display("same-row baseline: 2 tiles in %0d cycles", base_cycles);
|
|
|
|
sel = SEL_PF;
|
|
@(posedge clk);
|
|
pf_base_a <= 0; pf_base_b <= 200; pf_n_tiles <= 16'd2;
|
|
pf_job_start <= 1'b1;
|
|
t_start = $time;
|
|
@(posedge clk);
|
|
pf_job_start <= 1'b0;
|
|
for (k = 0; k < 2; k = k + 1) begin
|
|
#1;
|
|
while (!pf_tile_valid) @(posedge clk);
|
|
repeat(2) @(posedge clk);
|
|
pf_tile_consume <= 1'b1;
|
|
@(posedge clk);
|
|
pf_tile_consume <= 1'b0;
|
|
end
|
|
t_end = $time;
|
|
pf_cycles = (t_end - t_start) / CLK_PERIOD_NS;
|
|
$display("same-row prefetch: 2 tiles in %0d cycles", pf_cycles);
|
|
$display("=== REAL MEASURED COMPARISON (same-row, best case): baseline=%0d cycles, prefetch=%0d cycles, reduction=%0.1f%% ===",
|
|
base_cycles, pf_cycles, 100.0*(base_cycles-pf_cycles)/base_cycles);
|
|
|
|
$display("=== %0d/%0d tests, %0d errors ===", tests-errors, tests, errors);
|
|
if (errors == 0) $display("ALL TESTS PASSED (tb_ddr_prefetch_mgr)");
|
|
$finish;
|
|
end
|
|
endmodule
|