att_lutgemm_lane_w2.sv.md
Source reports/results/GEMM_REVISION_20261117/rtl_snapshot/att_lutgemm_lane_w2.sv.md · source md5 5a570c196a9b1a3e1472a407b2486583 · EAGLE4 FPGA archive, 2026-11-18
# Snapshot: verilog/clean7c/rtl/array/att/lutgemm_lane_w2.sv
Copied 2026-11-17T17:32:37Z from the clean7c tree (verilog repo commit 5998a7f1, md5 fa1aa8c446adb4a1ba537603d0f50d0d). Read-only copy for review; the live file is in the RTL repo.
```systemverilog
// =====================================================================================================================
// lutgemm_lane_w2 (clean7c rtl/array/att, WP3)
// =====================================================================================================================
// Imported from the shipped packaged copy ref/att_13be/packaged_ip/src/lutgemm_lane_w2.sv md5 6edf40360b7da7f7c05ea673828548eb (ATT 0xE4B713BE).
// Code = the shipped code; only this header, the items under 'clean7c edits' and the role include differ.
// Regenerate / verify: tools/wp3_import.py [--check]. Architecture + diagrams: docs/ARRAY.md.
//
// Purpose : one output column of the ATT body GEMV: W2 x A8 multiply-free LUT-GEMM lane with a per-lane GPTQ-v2 zero.
// Per 16-element chunk c of group g: sum_i a_i*(code_i - z) = sum_planes(2*T[hi] + T[lo]) - z*S_c, with
// T = {0, a0, a1, a0+a1} over activation pairs (the cluster's shared pair tables tbl_e/tbl_o) and z*S_c a 4:1
// select of {0, S, 2S, 3S} (S, 3S shared by the cluster). Two chunks per cycle (even + odd, URAM ports A/B);
// per-group INT sum, one scale multiply per group (FOLD_FABRIC 1: the 48-b fold add kept in fabric), result_q
// 48 b. TILE_PIPE with TP_SLIM 1: one accumulator bank, cleared by the column's last pair output.
// Users : u_array/g_grp[*].g_lane[*].g_dual.g_lutg.u_lane (512, SEQ_CHK 1) and the A8Q lead lane u_array/g_a8q.u_lead
// (datapath inputs tied 0, SEQ_CHK 0: only its chunk-index lookahead is used).
// Latency : chunk c's codes / scale / zero at cycle t (registered RAM reads addressed by *_next_out at t-1); WLAT is built in:
// qw/scale/zero are re-registered once (qw_d ...) to meet the cluster's activation register at t+1; CSA_LAT 3
// (csa_tree16_w); done one cycle after the column's last pair leaves the tree.
// Reset : synchronous active-low. KNOWN HAZARD (docs/ARRAY.md §7): the issue registers qw_d/qwb_d/sc_d/qz_d/ec_d are pure
// datapath but share the reset block with the valid/tag bits (same idiom as the MLPV lane's g_wlat1, whose qw_d
// bits place_design inverted on M1364 lane 84). Not changed here (lever L-RST-DP).
// Invariant: err_short (sticky) = wrong pair sequence (S_DRAIN timeout count or SEQ_CHK); report-only.
// Instances in the image: 513 (resolved parameters: rtl/array/SHIPPED_PARAMS.tsv, rows 'att lutgemm_lane_w2').
// Ports (generated from the port list; widths as declared, resolved values are in SHIPPED_PARAMS.tsv):
// input clk 1
// input rst_n 1
// input start 1
// input a_chunk signed [K_PAR*A_WIDTH-1:0]
// input a_chunk_b signed [K_PAR*A_WIDTH-1:0]
// input tbl_e [TBW-1:0]
// input tbl_o [TBW-1:0]
// input qw_word [31:0]
// input qw_word_b [31:0]
// input scale_q signed [SCALE_WIDTH-1:0]
// input qz [1:0]
// input s_e signed [ZW-1:0]
// input s3_e signed [ZW-1:0]
// input s_o signed [ZW-1:0]
// input s3_o signed [ZW-1:0]
// input n_chunks_run [CW-1:0]
// output chunk_idx_out [CW-1:0]
// output chunk_idx_b_out [CW-1:0]
// output chunk_idx_valid 1
// output chunk_idx_next_out [CW-1:0]
// output chunk_idx_b_next_out [CW-1:0]
// output group_idx_out [GW-1:0]
// output group_idx_next_out [GW-1:0]
// output acc_out signed [31:0]
// output result_q signed [RES_WIDTH-1:0]
// output done 1
// output start_dropped 1
// output err_short 1
// clean7c edits:
// - dead branch `g_csa20` (CSA_NARROW 0) removed -> stub (shipped :303-314)
// - dead branch `g_banks2` (TP_SLIM 0) removed -> stub (shipped :415-440)
// - dead branch `g_fold_dsp` (FOLD_FABRIC 0) removed -> stub (shipped :447-449)
// - default K 10240 -> 8192 (every lutgemm_lane_w2 instance of the image resolves 8192)
// - default CSA_NARROW 1'b0 -> 1'b1 (every lutgemm_lane_w2 instance of the image resolves 1'b1)
// - default TP_SLIM 1'b0 -> 1'b1 (every lutgemm_lane_w2 instance of the image resolves 1'b1)
// - default FOLD_FABRIC 1'b0 -> 1'b1 (every lutgemm_lane_w2 instance of the image resolves 1'b1)
// =====================================================================================================================
`timescale 1ns/1ps
`default_nettype none
(* keep_hierarchy = "yes" *)
module lutgemm_lane_w2 #(
parameter int K = 8192, // max reduction length (runtime n_chunks_run <= K/16)
parameter int A_WIDTH = 8,
parameter int GROUP = 128,
parameter int SCALE_WIDTH = 16,
parameter int RES_WIDTH = 48,
parameter bit TILE_PIPE = 1'b1,
parameter bit CSA_NARROW = 1'b1, // H2: tree at the minimum exact width
parameter int CSA_OW = A_WIDTH + 6, // narrowed tree width (RED R4 overrides)
parameter bit RED_PLANE = 1'b0,
parameter bit RED_GRP = 1'b0,
parameter bit TP_SLIM = 1'b1, // E2: single-bank TILE_PIPE
parameter bit SEQ_CHK = 1'b1, // pair-sequence check feeding err_short
parameter bit FOLD_FABRIC = 1'b1, // E3: TP_SLIM 48-b fold add kept out of the DSP
parameter bit RED_DROPV = 1'b0,
parameter bit RED_SLIMCLR = 1'b0,
// ----- derived -----
parameter int K_PAR = 16,
parameter int TE_W = A_WIDTH + 1, // table entry a0+a1
parameter int TBW = 8 * TE_W,
parameter int ZW = A_WIDTH + 6, // |3*S| < 2^(A+5)
parameter int N_CHUNKS = K / K_PAR,
parameter int CW = (N_CHUNKS <= 1) ? 1 : $clog2(N_CHUNKS + 2),
parameter int CPG = GROUP / K_PAR,
parameter int N_GROUPS = (K + GROUP - 1) / GROUP,
parameter int GW = (N_GROUPS <= 1) ? 1 : $clog2(N_GROUPS + 1),
parameter int N_PAIRS = (N_CHUNKS + 1) / 2,
parameter int PW = (N_PAIRS <= 1) ? 1 : $clog2(N_PAIRS + 2)
) (
input wire clk,
input wire rst_n,
input wire start,
input wire signed [K_PAR*A_WIDTH-1:0] a_chunk, // even chunk (issue cycle)
input wire signed [K_PAR*A_WIDTH-1:0] a_chunk_b, // odd chunk (issue cycle)
input wire [TBW-1:0] tbl_e, // shared pair sums (issue cycle)
input wire [TBW-1:0] tbl_o,
input wire [31:0] qw_word, // 16 codes, even chunk (cycle t)
input wire [31:0] qw_word_b, // 16 codes, odd chunk (cycle t)
input wire signed [SCALE_WIDTH-1:0] scale_q, // this lane's scale, cycle t
input wire [1:0] qz, // this lane's zero, cycle t
input wire signed [ZW-1:0] s_e, // shared S, 3S (issue+CSA_LAT-1)
input wire signed [ZW-1:0] s3_e,
input wire signed [ZW-1:0] s_o,
input wire signed [ZW-1:0] s3_o,
input wire [CW-1:0] n_chunks_run,
output wire [CW-1:0] chunk_idx_out,
output wire [CW-1:0] chunk_idx_b_out,
output wire chunk_idx_valid,
output wire [CW-1:0] chunk_idx_next_out,
output wire [CW-1:0] chunk_idx_b_next_out,
output wire [GW-1:0] group_idx_out,
output wire [GW-1:0] group_idx_next_out,
output reg signed [31:0] acc_out,
output reg signed [RES_WIDTH-1:0] result_q,
output reg done,
output reg start_dropped,
output reg err_short
);
localparam int CSA_LAT = 3;
localparam int CPG_BITS = (CPG <= 1) ? 1 : $clog2(CPG);
// term / tree / partial-sum widths
localparam int TW = CSA_NARROW ? (A_WIDTH + 2) : 20;
localparam int SW = CSA_NARROW ? CSA_OW : 26;
localparam int PSUM_W = CSA_NARROW ? (A_WIDTH + 8) : 28;
localparam int GACC_W = CSA_NARROW ? (A_WIDTH + 10) : 32;
`ifndef SYNTHESIS
initial if (CPG[0] != 1'b0)
$error("lutgemm_lane_w2: CPG (GROUP/K_PAR=%0d) must be EVEN for the pair/group alignment.", CPG);
initial if (TILE_PIPE && (N_PAIRS <= CSA_LAT + 2))
$error("lutgemm_lane_w2: TILE_PIPE=1 needs N_PAIRS > CSA_LAT+2 (got %0d).", N_PAIRS);
`endif
wire signed [PSUM_W-1:0] csa_sum_e, csa_sum_o;
wire csa_out_valid;
wire signed [PSUM_W:0] csa_pair_sum;
// ----------------------------------------------------------------
// FSM - pair walk (verbatim from the golden dual lane)
// ----------------------------------------------------------------
typedef enum logic [1:0] { S_IDLE, S_RUN, S_DRAIN, S_DONE } state_t;
state_t state, state_n;
wire state_is_idle = (state == S_IDLE);
logic [CW-1:0] nc_run_q;
wire [CW-1:0] nc_eff = (nc_run_q == '0) ? CW'(N_CHUNKS) : nc_run_q;
wire [PW-1:0] np_eff = PW'((nc_eff + CW'(1)) >> 1);
logic [PW-1:0] pair_idx, pair_idx_n;
logic [CW-1:0] drain_count, drain_count_n;
logic [PW-1:0] outs_recvd, outs_recvd_n;
wire at_terminal_pair = (state == S_RUN) && (pair_idx == np_eff - 1'b1);
wire col_accept = (state_is_idle && start)
|| (TILE_PIPE && at_terminal_pair && start);
always_ff @(posedge clk) begin
if (!rst_n) nc_run_q <= '0;
else if (col_accept) nc_run_q <= n_chunks_run;
end
always_ff @(posedge clk) begin
if (!rst_n) start_dropped <= 1'b0;
else if (start && !col_accept && (state != S_IDLE)) start_dropped <= 1'b1;
end
always_ff @(posedge clk) begin
if (!rst_n) begin
state <= S_IDLE; pair_idx <= '0; drain_count <= '0; outs_recvd <= '0;
end else begin
state <= state_n; pair_idx <= pair_idx_n;
drain_count <= drain_count_n; outs_recvd <= outs_recvd_n;
end
end
always_comb begin
state_n = state; pair_idx_n = pair_idx;
drain_count_n = drain_count; outs_recvd_n = outs_recvd;
case (state)
S_IDLE: if (start) begin
state_n = S_RUN; pair_idx_n = '0;
drain_count_n = '0; outs_recvd_n = '0;
end
S_RUN: begin
if (pair_idx == np_eff - 1'b1) begin
if (TILE_PIPE && start) begin
state_n = S_RUN; pair_idx_n = '0;
drain_count_n = '0; outs_recvd_n = '0;
end else begin
state_n = S_DRAIN; drain_count_n = '0;
end
end else pair_idx_n = pair_idx + 1'b1;
if (csa_out_valid) outs_recvd_n = outs_recvd + 1'b1;
end
S_DRAIN: begin
if (csa_out_valid) outs_recvd_n = outs_recvd + 1'b1;
if (outs_recvd == np_eff) state_n = S_DONE;
else if (drain_count >= CSA_LAT + 2) state_n = S_DONE;
drain_count_n = drain_count + 1'b1;
end
S_DONE: state_n = S_IDLE;
default: state_n = S_IDLE;
endcase
end
wire [CW-1:0] even_cur = CW'(pair_idx) << 1;
wire [CW-1:0] even_next = CW'(pair_idx_n) << 1;
assign chunk_idx_out = even_cur;
assign chunk_idx_b_out = even_cur + CW'(1);
assign chunk_idx_next_out = even_next;
assign chunk_idx_b_next_out = even_next + CW'(1);
assign chunk_idx_valid = (state == S_RUN);
wire [CW-1:0] grp_cur_full = (CPG <= 1) ? even_cur : (even_cur >> CPG_BITS);
wire [CW-1:0] grp_next_full = (CPG <= 1) ? even_next : (even_next >> CPG_BITS);
assign group_idx_out = grp_cur_full[GW-1:0];
assign group_idx_next_out = RED_GRP ? (grp_next_full[GW-1:0] + GW'(1)) // RED R3
: grp_next_full[GW-1:0];
// ----------------------------------------------------------------
// WLAT=1 issue registers (qw, scale, AND the per-lane zero)
// ----------------------------------------------------------------
reg [31:0] qw_d, qwb_d;
reg civ_d;
reg [CW-1:0] ec_d;
reg signed [SCALE_WIDTH-1:0] sc_d;
reg [1:0] qz_d;
reg tp_tag_d, tp_lcol_d;
reg col_tag;
always_ff @(posedge clk) begin
if (!rst_n) col_tag <= 1'b0;
else if (TILE_PIPE && col_accept) col_tag <= ~col_tag;
end
wire lastcol_pre = (pair_idx == np_eff - 1'b1);
always_ff @(posedge clk) begin
if (!rst_n) begin
qw_d <= '0; qwb_d <= '0; civ_d <= 1'b0; ec_d <= '0; sc_d <= '0; qz_d <= '0;
tp_tag_d <= 1'b0; tp_lcol_d <= 1'b0;
end else begin
qw_d <= qw_word; qwb_d <= qw_word_b; civ_d <= chunk_idx_valid;
ec_d <= even_cur; sc_d <= scale_q; qz_d <= qz;
tp_tag_d <= col_tag; tp_lcol_d <= lastcol_pre;
end
end
wire mac_in_valid = civ_d;
wire [CW-1:0] even_issue = ec_d;
wire signed [SCALE_WIDTH-1:0] scale_q_eff = sc_d;
wire tag_issue = tp_tag_d;
wire lastcol_issue = tp_lcol_d;
wire odd_valid_issue = ((even_issue + CW'(1)) < nc_eff);
// tree-issue valid (RED_DROPV drops pair 0 of every column)
wire mac_v = mac_in_valid && !(RED_DROPV && (even_issue == '0));
// ----------------------------------------------------------------
// LUT-GEMM lookups (no multiply). Odd codes forced to 0 past nc.
// ----------------------------------------------------------------
wire [31:0] qw_e_codes = qw_d;
wire [31:0] qw_o_codes = odd_valid_issue ? qwb_d : 32'd0;
function automatic signed [TW-1:0] lk2(input [1:0] m,
input signed [A_WIDTH-1:0] a0,
input signed [A_WIDTH-1:0] a1,
input signed [TE_W-1:0] s);
case (m)
2'd0: lk2 = '0;
2'd1: lk2 = TW'(a0);
2'd2: lk2 = TW'(a1);
default: lk2 = TW'(s);
endcase
endfunction
logic signed [TW-1:0] terms_e [0:15];
logic signed [TW-1:0] terms_o [0:15];
always_comb begin
for (int j = 0; j < 8; j++) begin
logic [1:0] r0e, r1e, r0o, r1o; // codes of elements 2j, 2j+1
logic [1:0] lo_e, hi_e, lo_o, hi_o; // bit-plane masks over the pair
logic signed [A_WIDTH-1:0] ae0, ae1, ao0, ao1;
r0e = qw_e_codes[(2*j)*2 +: 2]; r1e = qw_e_codes[(2*j+1)*2 +: 2];
r0o = qw_o_codes[(2*j)*2 +: 2]; r1o = qw_o_codes[(2*j+1)*2 +: 2];
lo_e = {r1e[0], r0e[0]}; hi_e = {r1e[1], r0e[1]};
lo_o = {r1o[0], r0o[0]}; hi_o = {r1o[1], r0o[1]};
if (RED_PLANE) begin // RED R2: planes swapped
{lo_e, hi_e} = {hi_e, lo_e};
{lo_o, hi_o} = {hi_o, lo_o};
end
ae0 = a_chunk [(2*j)*A_WIDTH +: A_WIDTH]; ae1 = a_chunk [(2*j+1)*A_WIDTH +: A_WIDTH];
ao0 = a_chunk_b[(2*j)*A_WIDTH +: A_WIDTH]; ao1 = a_chunk_b[(2*j+1)*A_WIDTH +: A_WIDTH];
terms_e[2*j] = lk2(lo_e, ae0, ae1, tbl_e[j*TE_W +: TE_W]);
terms_e[2*j+1] = lk2(hi_e, ae0, ae1, tbl_e[j*TE_W +: TE_W]) <<< 1;
terms_o[2*j] = lk2(lo_o, ao0, ao1, tbl_o[j*TE_W +: TE_W]);
terms_o[2*j+1] = lk2(hi_o, ao0, ao1, tbl_o[j*TE_W +: TE_W]) <<< 1;
end
end
wire signed [SW-1:0] tsum_e, tsum_o;
wire tval_e, tval_o;
generate
if (!CSA_NARROW) begin : g_csa20
// clean7c WP3: branch `g_csa20` (CSA_NARROW 0) is elaborated by NO instance of ATT 0xE4B713BE and was removed
// (shipped text: ref/att_13be/packaged_ip/src/lutgemm_lane_w2.sv:303-314). Selecting it is an elaboration
// error, never silently different hardware; restoring it is a lever (PLAN.md §6), not a cleanup.
C7_REMOVED_BRANCH__lutgemm_lane_w2__g_csa20 u_c7_removed ();
end else begin : g_csaw
csa_tree16_w #(.IN_W(TW), .OUT_W(SW)) u_csa_e (.clk(clk), .rst_n(rst_n),
.in_valid(mac_v), .prods(terms_e), .sum_out(tsum_e), .out_valid(tval_e));
csa_tree16_w #(.IN_W(TW), .OUT_W(SW)) u_csa_o (.clk(clk), .rst_n(rst_n),
.in_valid(mac_v), .prods(terms_o), .sum_out(tsum_o), .out_valid(tval_o));
end
endgenerate
// ----------------------------------------------------------------
// PER-LANE Z = zero * S (4:1 select of {0, S, 2S, 3S}, then one register)
// zero is delayed issue -> issue+CSA_LAT-1 to meet the cluster's S/3S.
// ----------------------------------------------------------------
logic [1:0] qz_sr [0:CSA_LAT-2];
always_ff @(posedge clk) begin
if (!rst_n) for (int q = 0; q < CSA_LAT-1; q++) qz_sr[q] <= '0;
else begin
qz_sr[0] <= qz_d;
for (int q = 1; q < CSA_LAT-1; q++) qz_sr[q] <= qz_sr[q-1];
end
end
wire [1:0] zq = qz_sr[CSA_LAT-2];
function automatic signed [ZW-1:0] zsel(input [1:0] z, input signed [ZW-1:0] s,
input signed [ZW-1:0] s3);
case (z)
2'd0: zsel = '0;
2'd1: zsel = s;
2'd2: zsel = s <<< 1;
default: zsel = s3;
endcase
endfunction
reg signed [ZW-1:0] z_e, z_o;
always_ff @(posedge clk) begin
if (!rst_n) begin z_e <= '0; z_o <= '0; end
else begin z_e <= zsel(zq, s_e, s3_e); z_o <= zsel(zq, s_o, s3_o); end
end
logic ov_sr [0:CSA_LAT-1];
always_ff @(posedge clk) begin
if (!rst_n) for (int q = 0; q < CSA_LAT; q++) ov_sr[q] <= 1'b0;
else begin
ov_sr[0] <= odd_valid_issue;
for (int q = 1; q < CSA_LAT; q++) ov_sr[q] <= ov_sr[q-1];
end
end
wire signed [ZW-1:0] z_o_eff = ov_sr[CSA_LAT-1] ? z_o : '0;
assign csa_sum_e = PSUM_W'($signed(tsum_e) - $signed(z_e));
assign csa_sum_o = PSUM_W'($signed(tsum_o) - $signed(z_o_eff));
assign csa_out_valid = tval_e;
assign csa_pair_sum = $signed(csa_sum_e) + $signed(csa_sum_o);
// ----------------------------------------------------------------
// From here down = the golden dual lane (TILE_PIPE banks, fold, scale).
// ----------------------------------------------------------------
logic tag_sr [0:CSA_LAT-1];
logic lcol_sr [0:CSA_LAT-1];
always_ff @(posedge clk) begin
if (!rst_n) begin
for (int t = 0; t < CSA_LAT; t++) begin tag_sr[t] <= 1'b0; lcol_sr[t] <= 1'b0; end
end else begin
tag_sr[0] <= tag_issue;
lcol_sr[0] <= lastcol_issue && mac_v;
for (int t = 1; t < CSA_LAT; t++) begin
tag_sr[t] <= tag_sr[t-1]; lcol_sr[t] <= lcol_sr[t-1];
end
end
end
wire tag_now = tag_sr[CSA_LAT-1];
wire lcol_now = lcol_sr[CSA_LAT-1];
wire new_tag = TILE_PIPE ? ~col_tag : 1'b0;
wire [CW-1:0] grp_issue_full = (CPG <= 1) ? even_issue : (even_issue >> CPG_BITS);
wire [CW-1:0] grp_end_full = ((grp_issue_full + CW'(1)) << CPG_BITS) - CW'(1);
wire [CW-1:0] grp_last = (grp_end_full < (nc_eff - CW'(1)))
? grp_end_full : (nc_eff - CW'(1));
wire last_in_grp_issue = odd_valid_issue ? ((even_issue + CW'(1)) == grp_last)
: (even_issue == grp_last);
logic last_sr [0:CSA_LAT-1];
logic signed [SCALE_WIDTH-1:0] sc_sr [0:CSA_LAT-1];
always_ff @(posedge clk) begin
if (!rst_n) begin
for (int s = 0; s < CSA_LAT; s++) begin last_sr[s] <= 1'b0; sc_sr[s] <= '0; end
end else begin
last_sr[0] <= last_in_grp_issue;
sc_sr[0] <= scale_q_eff;
for (int s = 1; s < CSA_LAT; s++) begin
last_sr[s] <= last_sr[s-1]; sc_sr[s] <= sc_sr[s-1];
end
end
end
wire last_now = last_sr[CSA_LAT-1];
wire signed [SCALE_WIDTH-1:0] scale_now = sc_sr[CSA_LAT-1];
wire signed [31:0] acc_next;
wire signed [GACC_W-1:0] g_total_w;
wire signed [RES_WIDTH-1:0] scaled_next_w;
wire cap_ev;
wire signed [31:0] acc_cap;
wire signed [RES_WIDTH-1:0] res_cap;
genvar ab;
generate
if (!TP_SLIM) begin : g_banks2
// clean7c WP3: branch `g_banks2` (TP_SLIM 0) is elaborated by NO instance of ATT 0xE4B713BE and was removed
// (shipped text: ref/att_13be/packaged_ip/src/lutgemm_lane_w2.sv:415-440). Selecting it is an elaboration
// error, never silently different hardware; restoring it is a lever (PLAN.md §6), not a cleanup.
C7_REMOVED_BRANCH__lutgemm_lane_w2__g_banks2 u_c7_removed ();
end else begin : g_bank1
// ---- TP_SLIM: one bank, cleared by the column's last pair output ----
logic signed [31:0] acc_s;
logic signed [GACC_W-1:0] gacc_s;
logic signed [RES_WIDTH-1:0] sacc_s;
assign acc_next = acc_s + $signed(csa_pair_sum);
assign g_total_w = gacc_s + $signed(csa_pair_sum);
if (!FOLD_FABRIC) begin : g_fold_dsp
// clean7c WP3: branch `g_fold_dsp` (FOLD_FABRIC 0) is elaborated by NO instance of ATT 0xE4B713BE and was removed
// (shipped text: ref/att_13be/packaged_ip/src/lutgemm_lane_w2.sv:447-449). Selecting it is an elaboration
// error, never silently different hardware; restoring it is a lever (PLAN.md §6), not a cleanup.
C7_REMOVED_BRANCH__lutgemm_lane_w2__g_fold_dsp u_c7_removed ();
end else begin : g_fold_fab
// product in the DSP, 48-b accumulate in fabric (E3: avoid the 2nd DSP)
(* keep = "true" *) wire signed [RES_WIDTH-1:0] fold_prod = $signed(g_total_w) * $signed(scale_now);
(* use_dsp = "no" *) wire signed [RES_WIDTH-1:0] fold_sum = sacc_s + fold_prod;
assign scaled_next_w = last_now ? fold_sum : sacc_s;
end
wire col_end = csa_out_valid && lcol_now;
always_ff @(posedge clk) begin
if (!rst_n) begin
acc_s <= '0; gacc_s <= '0; sacc_s <= '0;
end else if (csa_out_valid) begin
gacc_s <= last_now ? '0 : g_total_w; // lcol pair is always last-in-group
if (col_end && !RED_SLIMCLR) begin acc_s <= '0; sacc_s <= '0; end
else begin acc_s <= acc_next; sacc_s <= scaled_next_w; end
end
end
assign cap_ev = col_end;
assign acc_cap = acc_next;
assign res_cap = scaled_next_w;
end
endgenerate
always_ff @(posedge clk) begin
if (!rst_n) begin
acc_out <= '0; result_q <= '0; done <= 1'b0;
end else begin
done <= cap_ev;
if (cap_ev) begin acc_out <= acc_cap; result_q <= res_cap; end
end
end
// ----------------------------------------------------------------
// err_short: (a) S_DRAIN timeout exit with a short count; (b) SEQ_CHK pair
// sequence: each output's issue pair index must equal the per-column count.
// ----------------------------------------------------------------
// outs_recvd is exact only for a column accepted from IDLE: a chained (TILE_PIPE)
// accept resets it while the previous column's outputs are still in flight.
reg chained_q;
always_ff @(posedge clk) begin
if (!rst_n) chained_q <= 1'b0;
else if (col_accept) chained_q <= !state_is_idle;
end
wire drain_short = (state == S_DRAIN) && !chained_q && (outs_recvd != np_eff)
&& (drain_count >= CSA_LAT + 2);
wire seq_bad;
generate
if (SEQ_CHK) begin : g_seq
logic [PW-1:0] pidx_sr [0:CSA_LAT-1];
logic [PW-1:0] seq_cnt;
always_ff @(posedge clk) begin
if (!rst_n) begin
for (int t = 0; t < CSA_LAT; t++) pidx_sr[t] <= '0;
seq_cnt <= '0;
end else begin
pidx_sr[0] <= PW'(even_issue >> 1);
for (int t = 1; t < CSA_LAT; t++) pidx_sr[t] <= pidx_sr[t-1];
if (csa_out_valid) seq_cnt <= lcol_now ? '0 : (seq_cnt + 1'b1);
end
end
assign seq_bad = csa_out_valid && (pidx_sr[CSA_LAT-1] != seq_cnt);
end else begin : g_noseq
assign seq_bad = 1'b0;
end
endgenerate
always_ff @(posedge clk) begin
if (!rst_n) err_short <= 1'b0;
else if (drain_short || seq_bad) err_short <= 1'b1;
end
endmodule
`default_nettype wire
```