d4r/kernels/rr/rrswin_dec2_epilogues.md

cuda_dldn_engine_swin_dec2_kernel — the epilogues of phases 1…38

Companion to kernels/rr/rr_layer_spec.py dec2. Everything below was read out of ~/.cache/d4r-rr-corpus/0021-PREPASS_ENTRYPOINT_NAME.ptx, entry cuda_dldn_engine_swin_dec2_kernel (15796 statements).

0. Conventions

• sNNNN is a statement index in the linearisation rr_layer_spec.py documents (statements of the entry body; a wrapped { … } block and a 4-line mma.sync count as one statement, numbered at their first line). LNNNNN is the physical line of the same instruction in the corpus file, so every claim can be checked with sed -n 'LNNNNN,LNNNNN p' …ptx.
• An epilogue is the run of statements between one phase's last mma and the next phase's first mma. Because phase 1 is the first GEMM, the prologue (s1–s451) doubles as phase 1's prelude and is described here too.
• W denotes the prepared weight image: ld.param.u64 %rd1, [cuda_dldn_engine_swin_dec2_kernel_param_0+40] (s7, L1035) and cvta.to.global.u64 %rd32, %rd1 (s8, L1036). Every ld.weak.global.ca.v4.u32 reads W + 16*laneid + imm.
• The C/D register layout and the weight-addressing formula are fixed (see the settled notes): C/D reg0 = (row g, cols 2t,2t+1), reg1 = (row g+8, same cols), g = laneid>>2, t = laneid&3.
• Anything I could not pin down from the PTX is in §7 under uncharacterised.

1. Shared vocabulary

1.1 Addresses and parameters an epilogue touches

symbol	how it is obtained	statements
param_0	mov.b64 %rd7, …_param_0	s1, L1018
W (weight image)	ld.param.u64 %rd1, [param_0+40] → cvta… %rd32, %rd1	s7/s8, L1035–L1036
extents (ex, ey)	ld.param.v2.u32 {%r2147, %r2148}, [param_0+0]	s13, L1041
%r7 = 8·ex, %r8 = ey·8·ex	shl.b32 %r7, %r2147, 3 / mul.lo.s32 %r8, %r2148, %r7	s14/s15, L1042–L1043
block origins %r1, %r2	sub.s32 %r1, %r2142, %r2143 / sub.s32 %r2, %r2146, %r2144	s6/s12, L1034/L1040
%rd33 = param_0+8	ld.param.u64 %rd33, [param_0+8]	s28, L1056
texture / skip input	ld.param.u64 %rd2, [%rd7+24] = param_0+24	s2288, L4638
output plane arena	ld.param.u64 %rd571, [%rd7+48] = param_0+48 → cvta… %rd4, %rd571	s15333/s15334, L36645–L36646
block-origin table	ld.param.v2.u16 {%rs264, %rs265}, [param_0+80]	s4, L1032
window index tid.z	mov.u32 %r2350, %tid.z	s378, L1408
shared arena	.shared .align 4 .b8 _ZZ33…dec2_kernel…E4smem[9600]	L1027 (declaration; not a statement)
per-lane weight address	mul.wide.u32 %rd, %laneid, 16 + add.s64 %rd, W, %rd	every load block, e.g. s11444–s11445, L24247–L24248
per-lane table address	shl.b32 %r, %laneid, 2 → cvt.u64.u32 → and.b64 %rd, %r, 12 → add.s64 %rd, %rd32, %rd = W + ((laneid·4)&12)	e.g. s12456–s12460, L27063–L27068

The last row matters: the ld.global.v2.u16 / ld.global.u32 table loads in an epilogue read W + ((laneid<<2)&12) + off, i.e. the same 16-byte slot is read by the four lanes with equal laneid&3, and consecutive loads pick consecutive 4-byte words inside one 64-byte record — so those tables are indexed by column, not by row.

Two per-tid.z strides exist, both in phase 1's prelude and nowhere else:

group	base	statements
phase 1's B	W + 12288·tid.z + 16·laneid	s379–s384, L1409–L1416
phase 1's C bias	W + 192·tid.z + ((laneid·4)&12) + 49152…49328	s432–s439, L1512–L1521

%r2350·12288 (s379) is the only ×12288 in the file and %r2350·96 → ×2 (s432/s433) the only ×192, so no other phase's loads carry a window term.

1.2 Constants that survive between epilogues

register	first definition	f32/f64 literal	value used (after the cvt to f16)
%f476	s7488 mov.f32 %f476, 0f3C8CCB50	0.017186790704727173	f16 0x2466 = 0.017181396484375
%fd383	s7492 mov.f64 %fd383, 0dBFE1CC0000000000	−0.55615234375	f16 0xB873
%fd385	s7497 mov.f64 %fd385, 0d3FE1CC0000000000	+0.55615234375	f16 0x3873
%f478	s7503 mov.f32 %f478, 0f3F6D6000	0.92724609375	f16 0x3B6B
%f480	s7508 mov.f32 %f480, 0f3FB00000	1.375	f16 0x3D80
%fd1	s6132 mov.f64 %fd1, 0d3F20000000000000	2⁻¹³	f16 0x0800 = 0.0001220703125
%f861	s12301 mov.f32 %f861, 0f3ED306EB	0.4121621549129486	f16 0x3698 = 0.412109375
%f862	s12304 mov.f32 %f862, 0f3DA60DD6	0.0810810774564743	f16 0x2D30 = 0.0810546875
%f863	s12307 mov.f32 %f863, 0f3F000000	0.5	f16 0x3800
%f864	s12310 mov.f32 %f864, 0f40000000	2.0	f16 0x4000

%f861…%f864 are materialised inside E14 (s12301–s12312) and only re-cvt by E16, E18, E20, …, E36 (s12642 cvt.rn.f16.f32 low, %f861, …). %fd1 is defined once, in E1 (s6132), and only re-cvt by E13.

Also live across the region, as in the sibling kernel: %r5908 = 1 (s5595, L8140) and %r5919 = -1 (s6074, L9586) supply the butterfly delta and the membermask of every shfl.sync.bfly.b32 in the epilogues (s6075 shfl.sync.bfly.b32 %r5842,%r5838,%r5908,%r5845,%r5919); the group/width operand is per-instruction.

1.3 Two quantisation helpers

• cvt.rn.satfinite.e4m3x2.f16x2 — the requantisation used everywhere (f16x2_to_e4m3x2_satfinite_bits in ptx/lib/zluda_ptx_impl.cpp).
• cvt.rn.f16x2.e4m3x2 — its inverse, the unpack, used only when a shared tile that was stored e4m3-packed is read back (E1: 96 of them, s5594–s5690, L8139–L8437).
• rcp.approx.ftz.f32, rsqrt.approx.ftz.f32, ex2.approx.ftz.f32, div.approx.ftz.f32 — always wrapped as cvt.f32.f16 → op → cvt.rn.f16.f32 (round each step through f16).

2. Summary

epilogue	range	stmts	named operation
E1	s596–s7088	6493	patch expand into shared + per-column RMS norm + gain + restage
E2	s7113–s7119	7	next-B weight loads (P3)
E3	s7144–s7150	7	next-B weight loads (P4)
E4	s7175–s7181	7	next-B weight loads (P5)
E5	s7206–s7212	7	next-B weight loads (P6)
E6	s7237–s7243	7	next-B weight loads (P7)
E7	s7268–s7438	171	score-bias C-seed loads (24×512 B) + 80 packs → P8's A and B
E8	s7487–s11329	3843	cubic-exponent softmax, V transpose, pack
E9	s11378–s11546	169	pack P9's D → shared, per-column table → P10's C, next B
E10	s11559–s11577	19	1 shared A fragment + 6 next-B loads (P11)
E11	s11590–s11608	19	1 shared A fragment + 6 next-B loads (P12)
E12	s11621–s11639	19	1 shared A fragment + 6 next-B loads (P13)
E13	s11652–s12287	636	RMS norm of P13's D + gain, packs → P14's A and P16's A, next B/C
E14	s12300–s12556	257	clamped-cubic activation of P14's D, per-column table + residual → P15's C
E15	s12569–s12628	60	24 packs → P16's A, next B, P16's C bias
E16	s12641–s12804	164	clamped-cubic activation of P16's D → P17's A, next B
E17	s12817–s12876	60	24 packs → P18's A, next B, P18's C bias
E18	s12889–s13052	164	activation of P18's D → P19's A, next B
E19	s13065–s13124	60	24 packs → P20's A, next B, P20's C bias
E20	s13137–s13300	164	activation of P20's D → P21's A, next B
E21	s13313–s13372	60	24 packs → P22's A, next B, P22's C bias
E22	s13385–s13548	164	activation of P22's D → P23's A, next B
E23	s13561–s13620	60	24 packs → P24's A, next B, P24's C bias
E24	s13633–s13796	164	activation of P24's D → P25's A, next B
E25	s13809–s13868	60	24 packs → P26's A, next B, P26's C bias
E26	s13881–s14044	164	activation of P26's D → P27's A, next B
E27	s14057–s14116	60	24 packs → P28's A, next B, P28's C bias
E28	s14129–s14292	164	activation of P28's D → P29's A, next B
E29	s14305–s14364	60	24 packs → P30's A, next B, P30's C bias
E30	s14377–s14540	164	activation of P30's D → P31's A, next B
E31	s14553–s14612	60	24 packs → P32's A, next B, P32's C bias
E32	s14625–s14788	164	activation of P32's D → P33's A, next B
E33	s14801–s14860	60	24 packs → P34's A, next B, P34's C bias
E34	s14873–s15036	164	activation of P34's D → P35's A, next B
E35	s15049–s15108	60	24 packs → P36's A, next B, P36's C bias
E36	s15121–s15284	164	activation of P36's D → P37's A, next B
E37	s15297–s15504	208	pack → 12 guarded plane-arena scatter → B/C for P38
E38	s15511–s15796	286	4 D stores → shared, row max, softmax, 9+2 texture reads, surface store

---

3. The epilogues

E1 — s596–s7088: patch expand, RMS norm, gain, restage

6493 statements; op histogram (top): 1103 add.s32, 477 shl.b32, 446 mov.b32, 413 $label, 409 sub.s32, 355 min.u32, 288 mul.f16, 120 cvt.rn.satfinite.e4m3x2.f16x2, 96 cvt.rn.f16x2.e4m3x2, 96 rsqrt.approx.ftz.f32, 42 st.shared.* (34 u32 + 2 v2.u16 + 6 v4.u32), 42 ld.shared.* (24 v2.u16 + 18 v4.u32), 36 ld.global.v2.u16, 8 shfl.sync.bfly.b32, 1 ld.param, 2 ld.weak….

Sub-sections (bounded by the first/last statement of each op):

range	what
s596–s702	the head packs of phase 1's D (72 cvt.rn.satfinite…), → %r9…%r41
s716–s1478	per-lane index arithmetic + the 36 guarded patch stores (34 st.shared.u32 s770–s1460 + 2 st.shared.v2.u16 s743/s1478); 1st bar.sync at s1480
s1524–s2287	24 ld.shared.v2.u16 read back of the packed patch
s2288	ld.param.u64 %rd2, [%rd7+24]: the patch-gather buffer
s2444–s5593	24 clamped ld.global.v2.u16 gathered from that buffer
s5594–s5690	96 cvt.rn.f16x2.e4m3x2 unpacks of the read-back patch
s5693–s6276	the sum trees (196 add.f16 exact + 52 add.f16x2)
s6132	the 2⁻¹³ constant %fd1 (s6132 mov.f64 %fd1, 0d3F20000000000000)
s6075–s6128	the 8 shfl.sync.bfly.b32 (first at s6075)
s6282–s6659	96 rsqrt.approx.ftz.f32, each cvt.f32.f16 → rsqrt → cvt.rn.f16.f32
s6668–s6679	gain loads W + ((laneid·4)&12) + {49920…50096} (12 ld.global.v2.u16)
s5693–s6966	the 288 mul.f16 (two groups: inv · gain then x · (inv·gain))
s7008–s7054	24 packs → the 6 st.shared.v4.u32 at s7008/7021/7034/7044/7049/7054
s7059–s7082	bar.sync (s7059) + 18 ld.shared.v4.u32 (s7064–s7082) → phases 2…7's A
s7083–s7088	2 ld.weak (s7086/s7088) → phase 2's B

Evidence for the patch scatter (36 stores):

s743  L2836: st.shared.v2.u16 [%r2373], {%rs192, %rs193}
s770  L2865: st.shared.u32 [%r2386], %r9
s800  L2897: st.shared.u32 [%r2403], %r10
s1478 L3641: st.shared.v2.u16 [%r2787], {%rs262, %rs263}
s7008 L11717: st.shared.v4.u32 [%r6091], {%r6095, %r6094, %r6093, %r6092}
s7044 L11788: st.shared.v4.u32 [%r6110+6144], {%r6114, %r6113, %r6112, %r6111}
s7054 L11798: st.shared.v4.u32 [%r6110+7168], {%r6122, %r6121, %r6120, %r6119}

Each patch store is guarded exactly as in the sibling kernel (setp.gt.u32 %p…, %r…, 9 / or.pred / @%p bra …; the same (row·40 + col·8 + t)·4 index form — cf. rrswin_dec1_epilogues.md §3/E1, which carries the same 400-block emitter). The second staging area is at [%r6091], [%r6091+512], [%r6091+1024], [%r6110+6144], [%r6110+6656], [%r6110+7168], where %r6091 = smem + tid.z·2048 (s6994 shl.b32 … %r2350, 11) and %r6110 = smem + tid.z·3072 (s7040).

The norm:

s6132 L9664:  mov.f64 %fd1, 0d3F20000000000000        // 2^-13
s5693 L8430:  add.f16 %rs456,%rs457,%rs458
s6282 L10110: rsqrt.approx.ftz.f32 fl, fl
s6668 L10735: ld.global.v2.u16 {%rs1959, %rs1960}, [%rd247+49936]
s6681 L10749: mul.f16 %rs…, %rs…, %rs…                // inv * gain

There is no mean subtraction and no 1/N. The accumulated quantity is the raw sum of squares of the 3 patch channels plus the constant 2⁻¹³, and the norm is applied per column (the gain is read at W + ((laneid<<2)&12) + off, so it is constant across rows).

Inputs: phase 1's D (%r593…%r826, 12 fragments — phase 1 has nA = 12), W, param_0+8, param_0+24, %r1/%r2/%r7/%r8/%r2147/%r2148, %r2350 (tid.z). Outputs (live past s7088): the patch-expand st.shared regions, the 18 ld.shared.v4.u32 A fragments %r18995…%r19066, phase 2's B %r6125…%r6132, the 4 constants of §1.2 (%fd1, %f861…%f864 are not yet defined here).

E2…E6 — s7113–s7243: next-B loads

Five 7-statement blocks of identical shape:

s7113 L12005: mov.u32 %r6373, %laneid
s7114 L12007: mul.wide.u32 %rd…, %r6373, 16
s7115 L12008: add.s64 %rd…, %rd2?, %rd…
s7117 L12017: ld.weak.global.ca.v4.u32 { %r6374,…%r6377},[%rd250]
s7119 L12021: ld.weak.global.ca.v4.u32 { %r6378,…%r6381},[%rd251]

epilogue	weight block	destination phase
E2	50112…50636	P3's B
E3	53184…53708	P4's B
E4	51136…51660	P5's B
E5	54208…54732	P6's B
E6	52160…52684	P7's B

The weight sub-image is laid out P2, P4, P6, P3, P5, P7 (blocks of 1024 bytes at W + 50112 + 1024·k), not in phase order.

E7 — s7268–s7438: score-bias C-seed loads + packs → P8's A and B

171 statements, no ld.global outside the two groups below.

• 24 loads W + 16·laneid + 56256 + 512·i, i = 0…23, at s7272…s7318 (L12922…L13014) into %r7619…%r7714; the last block's add.s64 is s7317 add.s64 %rd283, %rd467, 17920. Byte block [56256, 68544) = 24 × 512 = 12288 bytes — phase 8's C score-bias seed (the phase table prints the last slot offset, 68044).
• 80 packs / 40 b32, s7319–s7438, whose sources are registers written by phases 3…7's mma (%r7129/%r7149/…, %r7229/…, %r7360…). The two destinations are %r8161…%r8272 (phase 8's B) and %r7907…%r8030 (phase 8's A), e.g.

s7320 L13020: cvt.rn.satfinite.e4m3x2.f16x2 %rs1984, %r7149
s7321 L13022: mov.b32 %r8161, {%rs1983, %rs1984}
s7391 L13185: cvt.rn.satfinite.e4m3x2.f16x2 %rs2032, %r7149
s7393 L13190: mov.b32 %r7907, {%rs2031, %rs2032}

s7439 then consumes them: mma … {A=%r7907,%r7908,%r7909,%r7910}, {B=%r8161,%r8162}, {C=%r7619,%r7620}. %r7149 is phase 3's first D (s7089–s7112) and %r7129/%r7360 likewise belong to phases 3/4/6/7, so both of phase 8's operands are packs of the six preceding projections.

E8 — s7487–s11329: cubic-exponent softmax, V transpose, pack

Byte-identical in kind to cuda_dldn_engine_swin_enc0_kernel's E5 (see rrswin_enc0_epilogues.md §3/E5): 1048 mov.b32, 672 cvt.rn.f16.f32, 384 cvt.rn.f16.f64, 192 each of fma.rn.f16x2 / cvt.f32.f16 / rcp.approx.ftz.f32 / mul.f16, 144 packs, 48 movmatrix, 16 shfl.sync.bfly.b32, 96 each of max/min/neg/abs.f16x2.

Sub-sections:

range	what
s7488–s7513	the 5 constants (§1.2 of the sibling file): s7488 0f3C8CCB50, s7492/s7497 the f64 clamps, s7503/s7508 the cubic pair
s7514–s9604	96 per-element groups (scale, clamp, cubic, and.b32 …,2145419232)
s9605–s9690	in-lane partial sums (add.f16x2)
s9691–s9820	16 shfl.sync.bfly → 8 row sums
s9821–s10582	192 rcp.approx.ftz.f32 → 96 reciprocals
s10583–s11065	192 mul.f16 → 96 probabilities
s11066–s11113	48 movmatrix.sync.trans.aligned.m8n8.b16 of phase 7's D
s11114–s11328	144 packs

Evidence:

s7514 L13706: and.b32 %r…, %r…, 2145419232               // 0x7FE07FE0
s9691 L20503: shfl.sync.bfly.b32 %r10441,%r10437,%r5908,%r10444,%r5919
s9821 L20829: rcp.approx.ftz.f32 fl, fl
s11066 L23128: movmatrix.sync.trans.aligned.m8n8.b16 %r10801, %r7378
s11114 L23272: cvt.rn.satfinite.e4m3x2.f16x2 %rs3432, %r10809

%r10801 is the first movmatrix result and its source %r7378 is phase 7's first D (s7244–s7267); the movmatrix sources run over phase 7's 48 D registers. The transposed results become phase 9's B (%r11407 ← mov.b32 {%rs3431,%rs3432} at s11116 after the pack at s11114), and the probability packs (%r11113 ← mov.b32 {%rs3479,%rs3480} at s11188) become phase 9's A.

The per-element function is the same cubic-exponent approximation as enc0's E5 (no row maximum, no bias add):

m  = clamp(f16(x * 0.017181396484375), -0.55615234375, +0.55615234375)
u  = f16(1.375 + m*(0.92724609375 - m*m))
expval = f16 from bits  ((u_bits << 5) & 0x7FE07FE0)

Memory: none (0 ld.*, 0 st.* in 3843 statements).

E9 — s11378–s11546: pack P9's D → shared, per-column table → P10's C

169 statements: 32 packs, 8 add.f16, 6 ld.weak, 12 ld.global.v2.u16, 4 st.shared.v4.u32, 1 ld.shared.v4.u32.

s11378 L24111: bar.sync 0
s11384 L24120: cvt.rn.satfinite.e4m3x2.f16x2 %rs3576, %r11141
s11396 L24147: st.shared.v4.u32 [%r19198], {%r19202, %r19201, %r19200, %r19199}
s11435 L24234: st.shared.v4.u32 [%r19198+1536], {%r19214, %r19213, %r19212, %r19211}
s11436 L24235: bar.sync 0
s11442 L24243: ld.shared.v4.u32 {%r19219,…%r19222}, [%r19218]
s11446 L24249: add.s64 %rd284, %rd469, 68544
s11451 L24259: add.s64 %rd286, %rd469, 69568
s11463 L24280: ld.global.v2.u16 {%rs4886, %rs4887}, [%rd473+136144]
s11475 L24293: add.f16 %rs3610,%rs4909,%rs459
s11477 L24300: mov.b32 %r11589, {%rs3607, %rs3610}

• 32 packs of phase 9's D → 16 b32 → four st.shared.v4.u32 at [%r19198 + {0,512,1024,1536}]; the bar.sync pair makes them visible, then one ld.shared.v4.u32 gives the first A fragment of phase 10.
• 6 ld.weak at W + 16·laneid + {68544, 69056, 69568, 70080, 70592, 71104} → phase 10's B.
• 12 ld.global.v2.u16 at W + ((laneid·4)&12) + {136128…136304} — a per-column vector (12 words per lane = 96 columns).
• 48 add.f16 adding that vector to register pairs, producing the 24 registers %r11589 %r11590 %r11599 %r11600 … = phase 10's C (confirmed at s11547: C = {%r11589, %r11590}).

Which registers the table is added to is ambiguous in this file. The operands are %rs456/%rs459 and their 22 siblings, and the only textual definition of %rs456/%rs459 is at s5693/s5694 (L8430/L8434) inside E1 (the E1 sum-of-squares tree); nothing between s5694 and s11475 writes them. So either E9's residual is genuinely carried from E1, or the printed PTX reuses a register name across two disjoint live ranges without a rename. See §7/U1.

E10/E11/E12 — s11559–s11639: one shared A fragment + next-B loads

Three 19-statement blocks:

s11562 L24597: ld.shared.v4.u32 {%r19226,…%r19229}, [%r19225+2048]
s11566 L24603: add.s64 %rd290, %rd475, 90048
s11571 L24613: add.s64 %rd292, %rd475, 91072

epilogue	shared A offset	weight block	destination phase
E10	+2048	90048…92620	P11's A, B
E11	+4096	111552…114124	P12's A, B
E12	+6144	133056…135628	P13's A, B

Each takes its single A fragment from the same shared staging region E9 wrote (offsets 2048/4096/6144 relative to %r19216) and reads 6 consecutive 512-byte weight fragments. All three phases take C = 0.

E13 — s11652–s12287: RMS norm of P13's D + gain

636 statements; 182 mov.b32, 144 mul.f16, 76 add.f16, 26 add.f16x2, 48 rsqrt.approx.ftz.f32, 4 shfl.sync.bfly, 24 packs, 12 ld.global.v2.u16.

range	op
s11654–s11749	unpack P13's D halves (%r12019…) and square them (48 mul.f16, s11655–s11749)
s11750–s11804	in-lane add.f16x2 partial sums
s11776–s11794	4 shfl.sync.bfly.b32
s11875–s11878	add.f16 of the halves, then + 2⁻¹³ (%fd1, defined at s6132)
s11883–s12068	48 rsqrt.approx.ftz.f32
s12072–s12083	gain loads W + ((laneid·4)&12) + {136336, 136352, …, 136496, 136320} (12 ld.global.v2.u16)
s12085–s12226	96 mul.f16 — inv · gain then x · (inv·gain)
s12231–s12242	next-B loads W + {136512, 137024, 137536, 138048, 138560, 139072} → phase 14's B
s12248–s12251	ld.global.u32 at W + ((laneid·4)&12) + {139584, 139600, 139616, 139632} → phase 14's C bias
s12252–s12287	24 packs → %r12414…%r12457, phase 14's A

At s12157/s12158 the same epilogue also emits a second scaled copy of P13's D:

s12157 L26127: mul.f16 %rs4190,%rs4360,%rs4046
s12158 L26130: mov.b32 %r18435, {%rs4190, %rs4193}

%rs4360 is the unpack of P13's first D (s11654). The 24 registers %r18435…%r18458 are re-used by every even phase's A pack (E15 s12594, E17 s12842, E19 …, and E37 s15297's neighbours), i.e. phases 14, 16, 18, …, P36 all share one A operand derived from phase 13.

E14 — s12300–s12556: activation of P14's D, table + residual → P15's C

257 statements. Three things happen:

1. s12301–s12440: the clamped-cubic activation on the 8 f16x2 registers %r12382 %r12392 %r12383 %r12393 %r12442 %r12452 %r12443 %r12453 (phase 14's D). This is the epilogue that materialises %f861…%f864 (s12301–s12312):

s12313 L26578: neg.f16x2 %r12467,%r12466
s12314 L26582: max.f16x2 %r12469,%r12382,%r12467
s12315 L26586: min.f16x2 %r12472,%r12469,%r12466
s12316 L26590: abs.f16x2 %r12475,%r12472
s12317 L26594: mul.f16x2 %r12477,%r12464,%r12475
s12318 L26598: sub.f16x2 %r12480,%r12463,%r12477
s12319 L26602: mul.f16x2 %r12483,%r12472,%r12480
s12320 L26606: add.f16x2 %r12486,%r12465,%r12483
s12321 L26610: mul.f16x2 %r12489,%r12382,%r12486

Per element: y = clamp(x,−2,+2), g = 0.5 + y·(0.412109375 − 0.0810546875·|y|), out = x·g — the same cubic ramp as the sibling kernel's E10. Reproduce the formula, not SiLU/GELU. 2. s12441–s12472: next-B and table loads. Six ld.weak at W + {139648, 140160, 140672, 141184, 141696, 142208} → phase 15's B; and 12 ld.global.v2.u16 at W + ((laneid·4)&12) + {142720…142896}. 3. s12473–s12556: the residual/table add and the packs. 48 add.f16 (add.f16 %rs4361,%rs4957,%rs4363 at s12473) combine the table with the 24 registers whose halves come from s11654 L24951: mov.b32 {%rs4360, %rs4363}, %r12019 — phase 13's D. The 24 results %r12737…%r12848 are phase 15's C; the 8 packs at s12545–s12556 give phase 15's A.

So phase 15 computes D15 = act(D14)·B15 + (D13 + table@142720).

E15 — s12569–s12628: packs of the shared A, next B, P16's C bias

60 statements:

s12572 L27414: add.s64 %rd320, %rd494, 142912
s12589 L27445: ld.global.u32 %r12908, [%rd497+145984]
s12593 L27450: cvt.rn.satfinite.e4m3x2.f16x2 %rs4511, %r18436
s12594 L27453: cvt.rn.satfinite.e4m3x2.f16x2 %rs4510, %r18435

• six ld.weak at W + {142912, 143424, 143936, 144448, 144960, 145472} → phase 16's B;
• four ld.global.u32 at W + ((laneid·4)&12) + {145984, 146000, 146016, 146032} → phase 16's C bias;
• 24 packs of %r18435…%r18458 — the shared A that E13 produced — so phase 16's A is bit-identical to phase 14's… (checked: %r12971 ← mov.b32 {%rs4510, %rs4511} at s12595 and %r12971 is phase 16's first A register; contrast phase 14's first A register %r12414 ← mov.b32 {%rs4334, %rs4335} at s12254, sourced from %r18435 at s12253 — the same register, so yes, identical).

E16/E18/…/E36 — the 164-statement activation epilogues

Twelve shape-identical 164-statement epilogues (shape hash 706fcc703f68): 36 mov.b32, 32 cvt.rn.f16.f32, 24 mul.f16x2, 8 each neg/max/min/abs/sub/add.f16x2, 6 ld.weak, no ld.global, no constants of their own (they re-cvt %f861…%f864).

Each applies the E14 activation to its own phase's D and packs 8 b32 → the next odd phase's A, and reads 6 weight fragments → the next odd phase's B. Evidence (E16):

s12642 L27622: cvt.rn.f16.f32 low, %f861
s12651 L27649: max.f16x2 %r13026,%r12939,%r13024      // phase 16's D
s12658 L27677: mul.f16x2 %r13046,%r12939,%r13043
s12782 L28107: ld.weak.global.ca.v4.u32 { %r13253,…},[%rd326]   // W+146048
s12795 L28135: mov.b32 %r13397, {%rs4534, %rs4535}    // phase 17's A

No table add and no residual: these epilogues produce only A and B.

E17/E19/…/E37-pre — the 60-statement pack epilogues

Eleven shape-identical 60-statement epilogues (shape hash a7b578456a5a): 24 packs, 12 mov.b32, 6 ld.weak, 4 ld.global.u32.

s12594 L27453: cvt.rn.satfinite.e4m3x2.f16x2 %rs4510, %r18435
s12842 L28285: cvt.rn.satfinite.e4m3x2.f16x2 %rs4542, %r18435

Each packs the same 24 registers %r18435…%r18458 (so every even phase P16, P18, …, P36 gets the identical A operand), reads 6 weight fragments → the next even phase's B, and 4 ld.global.u32 → the next even phase's C bias (E15→P16@145984, E17→P18@152192, E19→P20@158400, E21→P22@164608, E23→P24@170816, E25→P26@177024, E27→P28@183232, E29→P30@189440, E31→P32@195648, E33→P34@201856, E35→P36@208064).

Shape of the whole MLP region (E13–E37)

E13  normed tile  → P14's A (s12252)      ; shared tile T = %r18435… (s12158)
P14: A = f(D13),  B = W14, C = bias@139584  → D14   (48×96×96)
E14: act(D14) → P15's A ; P15's C = D13 + table@142720
P15: A = act(D14), B = W15, C = D13+table   → D15   (16×96×32)
E15: pack T → P16's A ; B = W16 ; P16's C = bias@145984
P16: A = pack(T),  B = W16, C = bias@145984 → D16   (48×96×96)
E16: act(D16) → P17's A ; B = W17
P17: A = act(D16), B = W17, C = D15         → D17   (16×96×32)
E17: pack T → P18's A ; B = W18 ; P18's C = bias@152192
P18: A = pack(T),  B = W18, C = bias        → D18
E18: act(D18) → P19's A ; P19's C = D17
 …   (the same two-phase motif repeats with the bias offsets of §2 until)
P37: A = act(D36), B = W37, C = D35         → D37
E37: pack D37 → 12 plane-arena stores ; P38: B = W38, C = bias@212736
P38: A = those packs, B = W38, C = bias     → D38   (48×48×96)

The claim "odd phase's C = previous odd phase's D" is machine-checked for every odd phase from P17 on (P15 is the exception, whose C is the register pair E14 builds). The claim "even phase's C comes from a ld.global.u32" holds for P14…P38.

E37 — s15297–s15504: pack → 12 guarded plane-arena stores → B/C for P38

208 statements; the only st.global in the entry (12 of them, all here).

(a) requantise, s15297–s15332. 12 groups of 2 cvt + 1 mov.b32 → the 12 b32 %r481…%r492 (phase 37's D).

(b) plane-arena scatter, s15333–s15482.

s15333 L36645: ld.param.u64 %rd571, [%rd7+48]        // = param_0+48
s15336 L36650: shr.u32 %r493, %r18989, 2             // g = laneid>>2
s15337 L36651: and.b32 %r494, %r18989, 3             // t = laneid&3
s15340 L36654: add.s32 %r19271, %r480, %r19269       // y = %r480 + (laneid>>5)
s15346 L36660: add.s32 %r19277, %r1, %r19270         // x = %r1 + (g&7)
s15351 L36665: shl.b32 %r19278, %r19277, 3           // x<<3
s15352 L36666: mad.lo.s32 %r495, %r7, %r19271, %r19278
s15354 L36668: selp.b32 %r496, -1, %r19279, %p1
s15359 L36674: st.global.u32 [%rd573], %r481

Stride register %r7 = 8·ex (s14). Each store is idx = 8·ex·y + 8·x + d, d = t or t|4, guarded by (y<0)|(y≥ey)|(laneid>63)|(x<0)|(x≥ex) (s15341–s15350, L36655–L36664); a guard failure stores -1 as the index, which the following setp.lt.s32 + bra turns into "skip the store".

Store values, bases and column offsets (g = laneid>>2, t = laneid&3, %r480 = %r2 + 2·tid.z at s11653/L24950, %r8 = ey·8·ex):

store	stmt	value	index base	d
1	s15359	%r481	idx1	t
2	s15368	%r482	idx1	t|4
3	s15401	%r483	idx2	t
4	s15409	%r484	idx2	t|4
5	s15419	%r485	idx1 + %r8	t
6	s15427	%r486	idx1 + %r8	t|4
7	s15437	%r487	idx2 + %r8	t
8	s15445	%r488	idx2 + %r8	t|4
9	s15455	%r489	idx1 + 2·%r8	t
10	s15463	%r490	idx1 + 2·%r8	t|4
11	s15473	%r491	idx2 + 2·%r8	t
12	s15481	%r492	idx2 + 2·%r8	t|4

with the two bases built as mad.lo.s32 %rBASE, 8·ex, y, 8·x:

base	stmt	y	x
idx1 = %r495	s15352, L36666	%r480 + (laneid>>5)	%r1 + (g&7)
idx2 = %r499	s15394, L36712	%r19505 + ((g+8)>>3)	%r1 + ((g+8)&7)

%r19505 is a second row origin: s15370 mov.u32 %r19511, %ctaid.y / s15372 shl.b32 %r19509, %r19511, 3 / s15375 sub.s32 %r19506, %r19509, %r19510 / s15376 add.s32 %r19505, %r19506, %r19507 with %r19507 = 2·tid.z (s15373/s15374), i.e. ctaid.y·8 − origin_y + 2·tid.z — so the two halves of this scatter start at different rows. The +%r8 (s15412 mad.lo.s32 %r502, %r2148, %r19493, %r495) and +2·%r8 (s15466 mad.lo.s32 %r511, %r2148, %r19496, %r505) forms then step one and two rows further.

(c) next B/C, s15483–s15504.

s15492 L36832: add.s64 %rd596, %rd600, 211200
s15493 L36834: ld.weak.global.ca.v4.u32 { %r19307,…%r19310},[%rd596]
s15497 L36842: ld.weak.global.ca.v4.u32 { %r19315,…%r19318},[%rd598]
s15503 L36851: ld.global.u32 %r19329, [%rd604+212736]
s15504 L36852: ld.global.u32 %r19339, [%rd604+212752]

Three weight fragments at W + {211200, 211712, 212224} → phase 38's B, two u32 at W + ((laneid&3)·4 &12) + {212736, 212752} → phase 38's C bias.

E38 — s15511–s15796: the final epilogue

286 statements; it consumes phase 38's four D accumulators (%r19360 %r19370 %r19497 %r19498) and writes the surface.

(a) staging, s15511–s15542.

s15511 L36895: bar.sync 0
s15522 L36908: st.shared.u32 [%r520], %r19360
s15526 L36913: st.shared.u32 [%r520+16], %r19370
s15539 L36927: st.shared.u32 [%r522], %r19361
s15541 L36930: st.shared.u32 [%r522+16], %r19371

Four guarded stores of the phase-38 D pairs into shared, indexed from %r518 = laneid>>2, %r519 = laneid&3 and %tid.z.

(b) coordinates and bounds check, s15543–s15570.

s15551 L36941: mov.u32 %r19403, %tid.x
s15559 L36949: add.s32 %r525, %r1, %r523             // x
s15560 L36950: add.s32 %r526, %r19512, %r524         // y
s15565 L36955: ld.param.v2.u32 {%r19418, %r19419}, [%rd634]
s15570 L36960: @%p412 bra $L__BB1_486

(c) row max over 5 shared values, s15571–s15591.

s15577 L36968: ld.shared.u32 %r19421, [%r19470]
s15583 L36974: ld.shared.u32 %r19442, [%r19470+16]
s15585 L36977: max.f16x2 %r19420,%r19421,%r19422
s15590 L36994: max.f16 %rs4961,%rs4958,%rs4963
s15592 L36999: sub.f16x2 %r19429,%r19421,%r19443

Five u32 (= 10 f16) per row, reduced in registers — no warp shuffle.

(d) softmax, s15592–s15676.

s15595 L37007: mul.ftz.f32 %f905, %f865, 0f3FB8AA3B   // * log2e
s15596 L37008: ex2.approx.ftz.f32 %f867, %f905
s15651 L37126: add.ftz.f32 %f922, %f920, %f882        // running row sum
s15653 L37128: div.approx.ftz.f32 %f883, %f904, %f922 // 1/rowsum, %f904 = 1.0

y = 2^((x−max)·log2e), p = y·(1/Σy) in f16, five f16x2 registers.

(e) 3×3 colour texture, s15677–s15758.

s15677 L37176: ld.param.v2.f32 {%f924, %f925}, [%rd635+136]
s15683 L37182: ld.param.u64 %rd622, [%rd635+88]
s15685 L37185: tex.base.2d.v4.f16.f32 {%rs4986,%rs4987,%rs4988,%rs4989}, [%rd606, {%f884,%f885}]
s15687 L37189: fma.rn.f16 %rs4990,%rs4986,%rs5000,%rs4983

%rd635 = param_0 (s15571), so the colour texture handle is param_0+88 and the coordinate scales are param_0+136. Nine tex.base.2d.v4.f16.f32 (s15685, 15697, 15709, 15721, 15726, 15732, 15744, 15750, 15755) cover the 3×3 neighbourhood of clamped (x−1, x, x+1) × (y−1, y, y+1), accumulated into 3 channels with fma.rn.f16.

(f) the two integer-coordinate textures, s15759–s15762.

s15759 L37357: ld.param.u64 %rd624, [%rd635+96]
s15760 L37359: tex.base.2d.v4.f16.s32 {%rs5130,%rs5131,%rs5132,%rs5133}, [%rd624, {%r525,%r526}]
s15761 L37361: ld.param.u64 %rd626, [%rd635+104]
s15762 L37363: tex.base.2d.v4.f16.s32 {%rs5134,%rs5135,%rs5136,%rs5137}, [%rd626, {%r525,%r526}]

These are the +96 / +104 texture reads the brief asks about — handles at param_0+96 and param_0+104, sampled at the integer pixel coordinate (%r525, %r526).

(g) combine, sigmoid gate, surface store, s15763–s15796.

s15763 L37366: cvt.f32.f16 %f902, %rs5138
s15764 L37369: mul.ftz.f32 %f935, %f902, 0fBFB8AA3B
s15765 L37370: ex2.approx.ftz.f32 %f936, %f935
s15766 L37371: add.ftz.f32 %f937, %f936, 0f3F800000
s15767 L37372: div.approx.ftz.f32 %f903, %f904, %f937    // 1/(1+2^(-log2e·v))
s15770 L37382: sub.f16 %rs5141,%rs5140,%rs5139           // 1 - sigmoid
s15771 L37386: mul.f16 %rs5144,%rs5118,%rs5139           // acc * sigmoid
s15772 L37390: fma.rn.f16 %rs5187,%rs5130,%rs5141,%rs5144// + tex96 * (1-sig)
s15777 L37410: set.nan.f16.f16 %rs5165,%rs5134,%rs5134   // + tex104 unless NaN
s15793 L37449: mov.u16 %rs5186, 0
s15794 L37451: sust.b.2d.v4.b16.zero [%rd629, {%r19489,%r526}], {%rs5187,%rs5188,%rs5189,%rs5186}

%rd629 = param_0+112 (s15582). The store column is %r525·8 (s15792 shl.b32 %r19489, %r525, 3), the row %r526; the fourth channel is the zero literal, so this is a 3-channel write into a 4-channel surface. The set.nan/bra triad (s15777–s15790) adds the +104 read only when it is not NaN.

Inputs: the 4 returned D registers, param_0+{48,88,96,104,112,136}, the shared scratch, constants 0f3FB8AA3B, 0fBFB8AA3B, 0f3F800000. Outputs: none (the kernel returns, s15796).

---

4. Texture reads, surface writes, and the +24 input

what	where
param_0+8 — input feature plane arena, read by phase 1's A loads	prologue s66…s451 (60 ld.global)
param_0+24 — the patch-gather source E1 reads	s2288 (ld.param.u64 %rd2, [%rd7+24]) and the 24 ld.global.v2.u16 at s2444…s5593
param_0+48 — the plane arena E37 scatters phase 37's output to	s15333, 12 st.global.u32 at s15359…s15481
param_0+88 — the colour texture handle	s15683, 9 tex.base.2d.v4.f16.f32 at s15685…s15755
param_0+96 — texture handle #2 (integer coords)	s15759/s15760
param_0+104 — texture handle #3 (integer coords)	s15761/s15762
param_0+112 — the output surface	s15582, sust.b.2d.v4.b16.zero s15794
param_0+136 — two f32 texture coordinate scales	s15677

The skip input at +24 supplies the patch-gather source. E1 reads it once per lane per stencil position and never writes it; the buffer is addressed in 4-byte elements (one f16x2 = 2 channels) with index clamp(row)·8·ex + clamp(col)·8 + clamp(t,0,7):

s2318 L4671: mad.lo.s32 %r3078, %r3068, %r7, %r3077   // clamp_row*(8*ex) + clamp_col*8
s2440 L4800: add.s32 %r19540, %r2996, %r2992          // + clamp(t, - , 7)
s2442 L4803: mul.wide.u32 %rd191, %r19540, 4
s2444 L4805: ld.global.v2.u16 {%rs314, %rs315}, [%rd192]

The same index form and the same 24-gather shape as the sibling kernel's §3/E1.

The surface writes are param_0+112 (E38, s15794), a 4-channel b16 surface written with 3 live channels. The plane-arena writes are E37's 12 st.global.u32 to param_0+48 (s15359…s15481).

Nothing reads param_0+48 back in this entry: param_0+48 is the source of exactly one ld.param (s15333) and never the base of a load. Likewise the texture handles at +88/+96/+104 are only ever tex.* operands.

5. The phase table, M/N/K checked

rr_layer_spec.py dec2's phase table with M/16 · N/8 · K/32 == mma evaluated on every row:

#	stmts	M	N	K	mma	M/16·N/8·K/32	holds?	weight bytes (rel. W)	bias bytes
1	s452–s595	192	384	128	144	12·48·4 = 2304	no	0…11788 (+12288·tid.z)	49152…49328 (+192·tid.z)
2	s7089–s7112	96	32	32	24	6·4·1 = 24	yes	50112…50636	–
3	s7120–s7143	96	32	32	24	24	yes	53184…53708	–
4	s7151–s7174	96	32	32	24	24	yes	51136…51660	–
5	s7182–s7205	96	32	32	24	24	yes	54208…54732	–
6	s7213–s7236	96	32	32	24	24	yes	52160…52684	–
7	s7244–s7267	96	32	32	24	24	yes	55232…55756	–
8	s7439–s7486	64	96	32	48	4·12·1 = 48	yes	none	56256…68044
9	s11330–s11377	192	96	96	48	12·12·3 = 432	no	none	–
10	s11547–s11558	16	96	32	12	1·12·1 = 12	yes	68544…71116	–
11	s11578–s11589	16	96	32	12	12	yes	90048…92620	–
12	s11609–s11620	16	96	32	12	12	yes	111552…114124	–
13	s11640–s11651	16	96	32	12	12	yes	133056…135628	–
14	s12288–s12299	48	96	96	12	3·12·3 = 108	no	136512…139084	139584…139632
15	s12557–s12568	16	96	32	12	12	yes	139648…142220	–
16	s12629–s12640	48	96	96	12	108	no	142912…145484	145984…146032
17	s12805–s12816	16	96	32	12	12	yes	146048…148620	–
18	s12877–s12888	48	96	96	12	108	no	149120…151692	152192…152240
19	s13053–s13064	16	96	32	12	12	yes	152256…154828	–
20	s13125–s13136	48	96	96	12	108	no	155328…157900	158400…158448
21	s13301–s13312	16	96	32	12	12	yes	158464…161036	–
22	s13373–s13384	48	96	96	12	108	no	161536…164108	164608…164656
23	s13549–s13560	16	96	32	12	12	yes	164672…167244	–
24	s13621–s13632	48	96	96	12	108	no	167744…170316	170816…170864
25	s13797–s13808	16	96	32	12	12	yes	170880…173452	–
26	s13869–s13880	48	96	96	12	108	no	173952…176524	177024…177072
27	s14045–s14056	16	96	32	12	12	yes	177088…179660	–
28	s14117–s14128	48	96	96	12	108	no	180160…182732	183232…183280
29	s14293–s14304	16	96	32	12	12	yes	183296…185868	–
30	s14365–s14376	48	96	96	12	108	no	186368…188940	189440…189488
31	s14541–s14552	16	96	32	12	12	yes	189504…192076	–
32	s14613–s14624	48	96	96	12	108	no	192576…195148	195648…195696
33	s14789–s14800	16	96	32	12	12	yes	195712…198284	–
34	s14861–s14872	48	96	96	12	108	no	198784…201356	201856…201904
35	s15037–s15048	16	96	32	12	12	yes	201920…204492	–
36	s15109–s15120	48	96	96	12	108	no	204992…207564	208064…208112
37	s15285–s15296	16	96	32	12	12	yes	208128…210700	–
38	s15505–s15510	48	48	96	6	3·6·3 = 54	no	211200…212236	212736…212752

Every phase whose M/16·N/8·K/32 does not equal mma is one the tool also marks grid = band, and every phase that holds is marked full. The mismatch factors are not constant (P1 ×16, P9 ×9, P14/…/P36 ×9, P38 ×9), so M, N and K cannot all be taken at face value for those rows. For P14 the reason is checkable and structural:

s12288 D=%r12342 A=%r12414 B=%r12293 C=bias@139584      (bo 136512)
s12290 D=%r12362 A=%r12434 B=%r12297 C=%r12342           (bo 137024)

— the same D accumulates products with B fragments from different 512-byte blocks and two different A quads. Under the settled weight formula (n = 16·tt + 8·(b>>3) + (L>>2), verified on enc0) P14's six blocks span n = 0…95, so N = 96 is supported; then the 3-mma chains must be summing over M or K, and neither is separately readable from the fragment structure. See §7/U2.

Which phases read no weight operand: P8 and P9. Both take B from registers the preceding epilogue packed (E7 packs phases 3…7's D for P8's A and B; E8 packs the probabilities and the transposed P7 for P9's A and B). Their bo is None for every mma.

Weight image extent as the tool measures it: the largest resolved offset is 212752 (s15504, 4 bytes wide) ⇒ 212756 bytes (1082 distinct slots). Phase 1's B and C bias carry the only tid.z terms (W + 12288·tid.z, W + 192·tid.z); with tid.z ∈ {0,1} (E38 rejects tid.z > 1 at s15561 setp.gt.u32 %p406, %r19503, 1) the extra 12288 bytes stay inside 212756. (INFERENCE — the tool drops the tid.z term, so the per-window base cannot be read off it directly.)

6. The plane arena (param_0 + 48) and the per-launch tables

• param_0+8 is read 60 times in the prologue (s66…s451) as the input feature plane that builds phase 1's 12 A fragments.
• param_0+24 is the patch-gather source (see §4); it is read, never written.
• param_0+48 is the output plane arena: written by E37's 12 st.global.u32 (s15359…s15481), never read. The entry has exactly 12 st.global and no other global store.
• The only other ld.param sites are the 4 in the prologue (§1.1) and the 5 in E38 ([%rd635+88/96/104/112/136], s15683/15759/15761/15582/15677) plus [%rd7+48] (s15333), [%rd7+24] (s2288) and the two param_0+40 re-reads (s15483/s15484).

There is no per-launch table generated into the plane arena by this kernel: the arena is only written (E37), and every table that looks like one (W + ((laneid<<2)&12) + {49920, 136128, 136320, 142720, …}) lives in the weight image, not the arena.

7. Uncharacterised

U1. E9's residual registers. The 24 registers that E9's per-column table adds into (%rs456/%rs459 and their siblings, s11473–s11544) have exactly one textual definition each, at s5693/s5694 (L8430/L8434) inside E1 — nothing between s5694 and s11473 writes them (grep -n '%rs456\b' returns L8430, L8913, L11184, L24297 only). So either the value is genuinely carried from E1's sum-of-squares tree, or the printed PTX reuses a register name across two disjoint live ranges without a rename. The two readings differ in what phase 10's C is (a table plus E1's partial sums, versus a table plus something unnameable), so I will not guess. Missing: a shared-memory/register dump at s11473, or the pre-rename SSA.

U2. The true M/N/K of the thirteen banded phases (P1, P9, P14, P16, …, P36, P38). For those rows M/16·N/8·K/32 ≠ mma (§5). nA counts distinct A register quads, which can be either distinct M-tiles or distinct K-slices of the same tile, and the accumulator chains mix distinct B operands, so the two cannot be separated from the fragment structure. Missing: a run with a weight-image dump, the _prep permutation, or the high-level layer definition.

U3. The identity of the 12288-byte score bias (P8's C). E7 loads it as 24 tiles × 512 bytes at W + 56256. Whether it is a relative position bias, a learned score bias, or a per-lane constant cannot be decided from the PTX: it is an opaque blob in a permuted weight image. Missing: the image's layout description or the model's parameter names.

U4. The identity of the per-column tables. W+49920…50096 (E1 gain), W+136128…136304 (E9), W+136320…136496 (E13 gain), W+142720…142896 (E14) are all read with the same W + ((laneid<<2)&12) + off pattern (12 words per lane). Their role is computable (E1/E13: multiply the inverse RMS; E9/E14: added to a residual before the next GEMM) but their names are not. The GEMM biases at +49152, +139584, +145984, +152192, +158400, +164608, +170816, +177024, +183232, +189440, +195648, +201856, +208064, +212736 are the same case.

U5. E1's patch-expand geometry. As in the sibling kernel, the 36 guarded st.shared are emitted as ~400 basic blocks with 413 labels and I could not reduce the lane→(row,col) map to a closed form. Established: 34 u32 + 2 v2.u16 patch stores, a second staging area of 6 v4.u32 stores at smem + tid.z·{2048,3072} + {0,512,1024,6144,6656,7168}, and the whole 9600-byte shared allocation. Missing: the source-level patchify expression or a shared-memory dump.

U6. Whether param_0+8 is an input plane or a scratch table. The prologue reads it 60 times with 4-byte elements and never writes it, and E1 does not read it (E1 reads param_0+24). So +8 and +24 are two different input buffers; which one holds the noisy colour plane and which the feature planes cannot be decided from the PTX. Missing: the host-side launch arguments.

U7. The tid.z strides. Phase 1's B and bias carry ×12288 and ×192 per-window strides and no later phase carries one. Whether the image is a concatenation of per-window sub-images or tid.z selects a batch element whose weights are interleaved cannot be decided here; consequently the "212756 bytes" of §5 is a lower bound.

U8. The logical meaning of E38's final expression. The tail computes out = acc·σ(v) + tex96·(1−σ(v)) + tex104 on the three channels gathered from the 3×3 colour stencil and the two integer-coordinate textures. The PTX gives the arithmetic exactly (§3/E38(g)) but not what model term it corresponds to. Missing: the high-level source or a reference implementation.

U9. Why every even phase shares one A operand. E13 emits two scaled copies of phase 13's D (the normed packs %r12414… at s12252 and %r18435… at s12158) and phases 14, 16, …, 36 all pack the second one. That makes the A operands of those twelve GEMMs bit-identical; whether that is the intended computation (one shared projection) or a consequence of a missed optimisation cannot be decided from the PTX. Missing: the high-level layer definition.

8. Quick acceptance index

requirement	where
every epilogue named and ranged	§2, §3 (E1…E38)
phase-1 epilogue's patch expand + norm	§3/E1
the norm (E1, E13)	§3/E1, §3/E13 — raw sum of squares + 2⁻¹³, no mean, no 1/N
the attention (score, softmax, P·V)	§3/E7, E8, E9; §3/E9's table add
the activations	§3/E14 (materialises %f861…%f864), E16, E18, …, E36
the patch expand	§3/E1 (36 st.shared), §7/U5
the final epilogue, textures at +96/+104, surface	§3/E38, §4
the texture reads at +96/+104	§3/E38(f), s15760 / s15762
the skip input at +24	§3/E1 (s2288), §4
the plane-arena writes	§3/E37 (s15359…s15481), §4, §6
the phase table with M/N/K checked	§5
weight image extent	§5 (212756 bytes, 1082 slots)
which phases read no weight	§5 (P8, P9)
uncharacterised	§7