ayo
7c5d3c9157
Add native K/M/RR inference engines, HIP kernels, replay and validation harnesses, and Windows DLSS setup and runtime support. Include GPU profiling tools, build and packaging scripts, platform integration patches, and implementation documentation.
3.8 KiB
K input kernel (hiluma_engine_input_depthinv_mvlo_hdr_v2_rel) - reverse-engineering notes
P = parameter block (248 bytes). Textures: 176 history colour (Y,Co,Cg,a compressed; linear), 184 motion, 192 depth, 200/208/216 exposure (1x1). Filter modes are NGX's own (cuTexObjectCreate): 168, 176 and 224 linear, the others point; all clamped, normalized coordinates. 200 = current exposure, 208 = previous exposure, 216 = current exposure.
entry
a = tex208 (0 -> 1), b = tex200 (0 -> 1), c = tex216 (0 -> 1) f152 = P144a ; f158 = P144b ; f1 = P156f158 (0 -> 1) ; f2 = (P148c)/f158 ; f3 = f158/f152 One thread per 2x2-pixel sub-block: gx = 16ctaid.x + tid.x, gy = 16ctaid.y + tid.y ; X = 4*(gx>>2) + 2*(tid.x&1), Y = 4gy + (tid.x&2) -> token (gx>>2, gy), sub index = (tid.x&1) + 2((tid.x>>1)&1) f4 = X+.5, f5 = Y+.5 ; (ix,iy) = roundHalfAway((f4,f5)P40 - .5 + P24) depth (tex192) at (ix,iy) and the four diagonal neighbours, each clamped as v > 0 ? min(P88 + v, P88 + P96) : P88 same dilation rule as the output kernel -> (dx,dy) ; mv = texelFetch(tex184, clampfn(P104 + (ix+dx,iy+dy))), max = P104 + P112 q = (f4,f5) + P8(mv + P16) ; hist = textureLod(tex176, q*P120) (f22..f25) ; P136 loaded (f201,f202)
the four pixels j of the sub-block: (X,Y), (X+1,Y), (X,Y+1), (X+1,Y+1)
each: nearest render texel, dilated motion mv_j (as above), q_j = pixel + .5 + P8*(mv_j + P16), hist_j = textureLod(tex176, q_jP120) lin_j = hist_j.rgb * expandK(hist_j.r) * f3 -> shared W[j][tid.y16+tid.x] (3 floats) local[j] = ((token centre in px) + P8*(mv_j + P16)) * P128, token centre = 4*(X/4 + .5), 4*(Y/4 + .5) invalid |= reset(P32 u8) || q_j*P136 outside [0,1] (accumulated over the four pixels: p3) r32 = 1 - subY ; r44 = r32 + X ; r45 = subX + Y
BB12: current colour statistics, 3x3 render texels around the sub-block centre
(cx,cy) = roundHalfAway((X+1, Y+1)P40 - .5 + P24) ; colour tex168, clamp origin P72, max P72+P80 ; f481 = P160 per tap (order (-1,-1),(0,-1),(1,-1),(-1,0),(0,0),(1,0),(-1,1),(0,1),(1,1)): rgb = f1max(c,0) ; Y,Co,Cg as in the output kernel wA = max(1/(Y+1), P160) ; S += wA*(Y,Co,Cg) t = log2(12max(Y,0)+1).6931472 / (max(Y,0)+1e-6) ; L = (Y,Co,Cg)t ; running min and max of L over the taps after the 9 taps: m = S/9 ; avg = m / max(1 - m.Y, P160) ; A = avg * t(avg.Y) (t as above: log compression) halfr = .5(max - min) ; den = 8*(max - min) + 1 (per channel) for each j: Hl = lin_j * t(lin_j.Y) ; d = max(|A - Hl| - halfr, 0)/den ; e_j = min(2d.Y + .5d.Co + .5d.Cg, 1) mismatch = .25 * sum_j e_j representative pixel of the sub-block: offset (1 - subY, subX), i.e. j' = 2subX + (1 - subY) Yc = exposed luma (f1 * (.25R + .5G + .25B) of max(c,0)) of the colour texel nearest to that pixel feat = textureLod(tex224 (previous token feature, 4 ch), local[j']) if invalid: mismatch = 0, Yh = Yc, feat = 0 else Yh = lin_j'.Y featSum = sum of feat over the token's four threads (shfl bfly 3, then 1) tc = (f2Yc) * max(1/(f2Yc+1), P160) ; th = (f2Yh) * max(1/(f2Yh+1), P160) then a switch on the sub index
output: 4 f16 per sub-block into buffer P240 at ((tokY*P64 + tokX)16 + sub4) (16 channels per token: the network input)
G(x) = x > .0031308 ? 1.055x^(1/2.4) - .055 : 12.92x (sRGB transfer) out0 = G(sat(tc)) ; out1 = G(sat(th)) ; out2 = .25*featSum[sub] (non-finite -> 0) ; out3 = mismatch (non-finite -> 0) No barrier: the shared array is only per-thread scratch.
display-resolution motion (frame flag 4, D4RO0003)
Vectors are output-sized and already in output pixels (scale 1 by default). Each output pixel j of a token uses its own
vector: mv_j = mvScale*(tex184(clamp(X+j)) + mvOffs), with no diagonal depth dilation and no render-texel lookup.
The rest (q_j, history fetch, local terms) is unchanged. The package must carry D4RO0003.