wgblas 2.2.0 → 2.3.0

package/src/shaders/dtrmv.wgsl

@@ -0,0 +1,111 @@
+// dtrmv: y := op(A) * x, double-double (Dekker) f64 emulation of strmv
+// (triangular matrix-vector product). A, x, and y are each split into an f32
+// (hi, lo) pair; WGSL has no f64 type. A is n×n triangular — only the
+// triangle specified by uplo is referenced. Like strmv.wgsl, wgblas's trmv
+// takes a separate output vector y rather than overwriting x in place (the
+// standard BLAS signature is in-place), so there is no aliasing/read-write-
+// ordering concern the way real in-place trmv would have — this is
+// structurally just dsymv.wgsl's per-row DD tree reduction with a triangular
+// (not full-n, not mirrored) column range per row, same shape as dsyr.wgsl's
+// per-row-varying range (main/tail split computed inside the row loop, since
+// range length depends on i).
+
+@group(0) @binding(0) var<storage, read>       AHi: array<f32>;
+@group(0) @binding(1) var<storage, read>       ALo: array<f32>;
+@group(0) @binding(2) var<storage, read>       xHi: array<f32>;
+@group(0) @binding(3) var<storage, read>       xLo: array<f32>;
+@group(0) @binding(4) var<storage, read_write> yHi: array<f32>;
+@group(0) @binding(5) var<storage, read_write> yLo: array<f32>;
+
+struct Params {
+  n:     u32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+  trans: u32,  // 0 = no-transpose, 1 = transpose
+  uplo:  u32,  // 0 = lower, 1 = upper
+  diag:  u32,  // 0 = non-unit, 1 = unit
+}
+
+@group(0) @binding(6) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> tile: array<DD, 64>;
+
+@compute @workgroup_size(64)
+fn dtrmv_main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  // Effective "upper" range for row i: op(A)[i,j] is stored at A[i,j] for
+  // no-transpose+upper or transpose+lower (range [i, n)); at A[j,i] for
+  // no-transpose+lower or transpose+upper (range [0, i]).
+  let isUpperRange = (params.trans == 0u) == (params.uplo == 1u);
+
+  for (var i = wgid.x; i < params.n; i += nwg.x) {
+    let rangeStart = select(0u, i, isUpperRange);
+    let rangeEnd   = select(i + 1u, params.n, isUpperRange);
+
+    // Range length varies per row, but every thread in the workgroup runs
+    // the SAME row at the same time, so the main/tail split computed from
+    // rangeStart/rangeEnd is already uniform across threads for this row —
+    // just not the same across different rows (see dsyr.wgsl).
+    let rangeLen    = rangeEnd - rangeStart;
+    let range_floor = rangeStart + (rangeLen / WGS) * WGS;
+    let mainIters   = (range_floor - rangeStart) / WGS;
+    let hasTail     = select(0u, 1u, range_floor < rangeEnd);
+
+    var acc = DD(0.0, 0.0);
+
+    for (var iter = 0u; iter < mainIters; iter++) {
+      let j    = rangeStart + lid.x + iter * WGS;
+      let addr = select(j * params.lda + i, i * params.lda + j, params.trans == 0u);
+      let isUnitDiag = params.diag == 1u && j == i;
+      let aVal = DD(
+        select(AHi[addr], 1.0, isUnitDiag),
+        select(ALo[addr], 0.0, isUnitDiag),
+      );
+      let ix = j * params.incx;
+      let prod = ddMulProtected(aVal, DD(xHi[ix], xLo[ix]), lid.x);
+      acc = ddAddProtected(acc, prod, lid.x);
+    }
+
+    for (var iter = 0u; iter < hasTail; iter++) {
+      let j     = range_floor + lid.x;
+      let valid = j < rangeEnd;
+      let safeJ = select(rangeStart, j, valid); // rangeLen is always >= 1, so rangeStart is a safe in-range fallback
+      let addr  = select(safeJ * params.lda + i, i * params.lda + safeJ, params.trans == 0u);
+      let isUnitDiag = params.diag == 1u && safeJ == i;
+      let aVal = DD(
+        select(AHi[addr], 1.0, isUnitDiag),
+        select(ALo[addr], 0.0, isUnitDiag),
+      );
+      let ix = safeJ * params.incx;
+      let prod = ddMulProtected(aVal, DD(xHi[ix], xLo[ix]), lid.x);
+      let contribution = DD(select(0.0, prod.hi, valid), select(0.0, prod.lo, valid));
+      acc = ddAddProtected(acc, contribution, lid.x);
+    }
+
+    tile[lid.x] = acc;
+    workgroupBarrier();
+
+    // Inactive threads combine against a throwaway partner and discard it
+    // (ddAddProtected must be called unconditionally by every thread).
+    for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+      let partner = select(lid.x, lid.x + s, lid.x < s);
+      let combined = ddAddProtected(tile[lid.x], tile[partner], lid.x);
+      workgroupBarrier(); // all threads must read tile[] above before any write below
+      if (lid.x < s) { tile[lid.x] = combined; }
+      workgroupBarrier();
+    }
+
+    if (lid.x == 0u) {
+      let iy = i * params.incy;
+      yHi[iy] = tile[0].hi;
+      yLo[iy] = tile[0].lo;
+    }
+    // All 64 threads must agree before the next row reuses tile[].
+    workgroupBarrier();
+  }
+}

package/src/shaders/dtrsv_apply_inverse.wgsl

@@ -0,0 +1,60 @@
+// dtrsv_apply_inverse: double-double (Dekker) f64 emulation of
+// strsv_apply_inverse.wgsl — given a precomputed block inverse (from
+// dtrsv_invert_block.wgsl), computes this block's solution as a dense
+// matrix-vector multiply against the block's current remainder in x.
+// Ainv, x, and the per-row accumulation are each split into an f32 (hi, lo)
+// pair; WGSL has no f64 type.
+//
+// Unlike dsymv/dtrmv's per-row reduction across 64 threads, each thread here
+// owns one whole row's dot product independently (blockLen <= WGS, so one
+// thread per row already covers it, no tree reduction needed) — same shape
+// as dgemv_t.wgsl's per-thread accumulation. The f32 original early-returns
+// threads with `lid.x >= blockLen` (the last, possibly-short block); DD
+// can't do that, since every thread must call ddMulProtected/ddAddProtected
+// the same number of times. Instead every thread runs the identical
+// `blockLen`-iteration loop (reading past-blockLen rows of Ainv, which the
+// zero-initialized, never-written buffer backing them makes safe garbage —
+// see dgemv_t.wgsl's clamped-dummy-index technique) and only the final
+// write is gated.
+
+@group(0) @binding(0) var<storage, read>       AinvHi: array<f32>;
+@group(0) @binding(1) var<storage, read>       AinvLo: array<f32>;
+@group(0) @binding(2) var<storage, read_write> xHi: array<f32>;
+@group(0) @binding(3) var<storage, read_write> xLo: array<f32>;
+
+struct Params {
+  incx:       u32,
+  blockIndex: u32,
+  blockStart: u32,
+  blockEnd:   u32,
+}
+
+@group(0) @binding(4) var<uniform> params: Params;
+
+const BLOCK_SIZE: u32 = 64u;
+var<workgroup> xLocal: array<DD, 64>;
+
+@compute @workgroup_size(64)
+fn dtrsv_apply_inverse_main(@builtin(local_invocation_id) lid: vec3u) {
+  let blockLen = params.blockEnd - params.blockStart;
+
+  if (lid.x < blockLen) {
+    let ix = (params.blockStart + lid.x) * params.incx;
+    xLocal[lid.x] = DD(xHi[ix], xLo[ix]);
+  }
+  workgroupBarrier();
+
+  let ainvBase = params.blockIndex * BLOCK_SIZE * BLOCK_SIZE;
+  var acc = DD(0.0, 0.0);
+  for (var j = 0u; j < blockLen; j++) {
+    let aidx = ainvBase + lid.x * BLOCK_SIZE + j;
+    let prod = ddMulProtected(DD(AinvHi[aidx], AinvLo[aidx]), xLocal[j], lid.x);
+    acc = ddAddProtected(acc, prod, lid.x);
+  }
+
+  if (lid.x < blockLen) {
+    let ix = (params.blockStart + lid.x) * params.incx;
+    xHi[ix] = acc.hi;
+    xLo[ix] = acc.lo;
+  }
+}

package/src/shaders/dtrsv_invert_block.wgsl

@@ -0,0 +1,148 @@
+// dtrsv_invert_block: double-double (Dekker) f64 emulation of
+// strsv_invert_block.wgsl — computes ONE column (workgroup_id.x) of ONE
+// block's (workgroup_id.y) explicit inverse, via the same one-row-at-a-time
+// substitution, solving against a unit basis vector e_col. A, Ainv, and the
+// running accumulation are each split into an f32 (hi, lo) pair; WGSL has no
+// f64 type.
+//
+// This is the first routine in the f64 port order to use ddDivProtected (the
+// non-unit-diagonal division) — deliberately last per TODO.md, since
+// division is where dnrm2 found real double-double edge-case bugs during
+// the L1 port. The division only runs once per (column, step) — same
+// barrier-uniformity requirement as every other protected op here — so
+// every thread in the workgroup computes it redundantly from the
+// already-shared `tile[0]` reduction result (same pattern dgemv_n uses for
+// its O(1) alpha/beta combine after the per-row reduction), with only
+// `lid.x==0` writing the result. `params.diag` is uniform across the whole
+// dispatch (not per-thread), so branching on it to skip the division
+// entirely for a unit diagonal is safe — unlike dtrmv.wgsl's per-element
+// diag check, which varies per thread and needed select() instead.
+
+@group(0) @binding(0) var<storage, read>       AHi: array<f32>;
+@group(0) @binding(1) var<storage, read>       ALo: array<f32>;
+@group(0) @binding(2) var<storage, read_write> AinvHi: array<f32>;
+@group(0) @binding(3) var<storage, read_write> AinvLo: array<f32>;
+
+struct Params {
+  n:     u32,
+  lda:   u32,
+  trans: u32,  // 0 = no-transpose, 1 = transpose
+  uplo:  u32,  // 0 = lower, 1 = upper
+  diag:  u32,  // 0 = non-unit, 1 = unit
+}
+
+@group(0) @binding(4) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+const BLOCK_SIZE: u32 = 64u;
+var<workgroup> tile: array<DD, 64>;
+
+fn readA(i: u32, j: u32) -> DD {
+  let idx = select(j * params.lda + i, i * params.lda + j, params.trans == 0u);
+  return DD(AHi[idx], ALo[idx]);
+}
+
+@compute @workgroup_size(64)
+fn dtrsv_invert_block_main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+) {
+  let col = wgid.x;
+  let blockIndex = wgid.y;
+  let blockStart = blockIndex * BLOCK_SIZE;
+  var blockEnd = blockStart + BLOCK_SIZE;
+  if (blockEnd > params.n) { blockEnd = params.n; }
+  let blockLen = blockEnd - blockStart;
+
+  if (col >= blockLen) { return; }
+
+  let ainvBase = blockIndex * BLOCK_SIZE * BLOCK_SIZE;
+  let forward = (params.trans == 0u) == (params.uplo == 0u);
+
+  if forward {
+    for (var r = lid.x; r < col; r += WGS) {
+      AinvHi[ainvBase + r * BLOCK_SIZE + col] = 0.0;
+      AinvLo[ainvBase + r * BLOCK_SIZE + col] = 0.0;
+    }
+  } else {
+    for (var r = col + 1u + lid.x; r < blockLen; r += WGS) {
+      AinvHi[ainvBase + r * BLOCK_SIZE + col] = 0.0;
+      AinvLo[ainvBase + r * BLOCK_SIZE + col] = 0.0;
+    }
+  }
+  storageBarrier();
+  workgroupBarrier();
+
+  let numSteps = select(col + 1u, blockLen - col, forward);
+  for (var step = 0u; step < numSteps; step++) {
+    let localRow = select(col - step, col + step, forward);
+    let i = blockStart + localRow;
+
+    // Accumulation range over lj: [col, localRow) forward, [localRow+1, col+1) backward.
+    // Range length varies per step, but every thread runs the SAME step at
+    // the same time, so the main/tail split is already uniform for this
+    // step — just not the same across different steps (see dsyr.wgsl).
+    let ljStart = select(localRow + 1u, col, forward);
+    let ljEnd   = select(col + 1u, localRow, forward);
+    let rangeLen    = ljEnd - ljStart;
+    let range_floor = ljStart + (rangeLen / WGS) * WGS;
+    let mainIters   = (range_floor - ljStart) / WGS;
+    let hasTail     = select(0u, 1u, range_floor < ljEnd);
+
+    var acc = DD(0.0, 0.0);
+
+    for (var iter = 0u; iter < mainIters; iter++) {
+      let lj = ljStart + lid.x + iter * WGS;
+      let aij = readA(i, blockStart + lj);
+      let aidx = ainvBase + lj * BLOCK_SIZE + col;
+      let ainv = DD(AinvHi[aidx], AinvLo[aidx]);
+      let prod = ddMulProtected(aij, ainv, lid.x);
+      acc = ddAddProtected(acc, prod, lid.x);
+    }
+
+    for (var iter = 0u; iter < hasTail; iter++) {
+      let lj    = range_floor + lid.x;
+      let valid = lj < ljEnd;
+      let safeLj = select(ljStart, lj, valid); // ljStart is always in-range when rangeLen > 0, the only case hasTail can be 1
+      let aij = readA(i, blockStart + safeLj);
+      let aidx = ainvBase + safeLj * BLOCK_SIZE + col;
+      let ainv = DD(AinvHi[aidx], AinvLo[aidx]);
+      let prod = ddMulProtected(aij, ainv, lid.x);
+      let contribution = DD(select(0.0, prod.hi, valid), select(0.0, prod.lo, valid));
+      acc = ddAddProtected(acc, contribution, lid.x);
+    }
+
+    tile[lid.x] = acc;
+    workgroupBarrier();
+
+    // Inactive threads combine against a throwaway partner and discard it
+    // (ddAddProtected must be called unconditionally by every thread).
+    for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+      let partner = select(lid.x, lid.x + s, lid.x < s);
+      let combined = ddAddProtected(tile[lid.x], tile[partner], lid.x);
+      workgroupBarrier(); // all threads must read tile[] above before any write below
+      if (lid.x < s) { tile[lid.x] = combined; }
+      workgroupBarrier();
+    }
+
+    // tile[0] now holds the full accumulation, visible to every lane — every
+    // thread redundantly finishes the O(1) rhs/division so the protected
+    // ops below stay uniformly called (only the write is gated).
+    let e = DD(select(0.0, 1.0, localRow == col), 0.0);
+    let rhs = ddSubProtected(e, tile[0], lid.x);
+
+    var val: DD;
+    if params.diag == 1u {
+      val = rhs;
+    } else {
+      val = ddDivProtected(rhs, readA(i, i), lid.x);
+    }
+
+    if (lid.x == 0u) {
+      AinvHi[ainvBase + localRow * BLOCK_SIZE + col] = val.hi;
+      AinvLo[ainvBase + localRow * BLOCK_SIZE + col] = val.lo;
+    }
+    storageBarrier();
+    workgroupBarrier();
+  }
+}

package/src/shaders/dtrsv_update.wgsl

@@ -0,0 +1,111 @@
+// dtrsv_update: double-double (Dekker) f64 emulation of strsv_update.wgsl —
+// subtracts a solved block's contribution from every remaining row in
+// parallel (one workgroup per row, like dtrmv.wgsl). A, x, and the per-row
+// accumulation are each split into an f32 (hi, lo) pair; WGSL has no f64
+// type. No diag/masking needed: this region never touches the diagonal.
+//
+// The column range [blockStart, blockEnd) is the same fixed width for every
+// row in a dispatch (not per-row-varying the way dtrmv's triangular range
+// is), so the main/tail split is computed once, outside the row loop — same
+// shape as dger.wgsl's column loop.
+
+@group(0) @binding(0) var<storage, read>       AHi: array<f32>;
+@group(0) @binding(1) var<storage, read>       ALo: array<f32>;
+@group(0) @binding(2) var<storage, read_write> xHi: array<f32>;
+@group(0) @binding(3) var<storage, read_write> xLo: array<f32>;
+
+struct Params {
+  n:          u32,
+  incx:       u32,
+  lda:        u32,
+  trans:      u32,  // 0 = no-transpose, 1 = transpose
+  uplo:       u32,  // 0 = lower, 1 = upper
+  blockStart: u32,
+  blockEnd:   u32,  // exclusive
+}
+
+@group(0) @binding(4) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> tile: array<DD, 64>;
+
+@compute @workgroup_size(64)
+fn dtrsv_update_main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  // forward: remaining rows are [blockEnd,n); backward: [0,blockStart).
+  // Uniform across the whole dispatch (derived from params only), so an
+  // early return here is safe — never a partial-workgroup divergence.
+  let forward = (params.trans == 0u) == (params.uplo == 0u);
+
+  var rangeStart: u32;
+  var rangeEnd: u32;
+  if forward {
+    rangeStart = params.blockEnd;
+    rangeEnd = params.n;
+  } else {
+    rangeStart = 0u;
+    rangeEnd = params.blockStart;
+  }
+
+  if (rangeStart >= rangeEnd) { return; }
+  let count = rangeEnd - rangeStart;
+
+  let colCount    = params.blockEnd - params.blockStart;
+  let col_floor   = (colCount / WGS) * WGS;
+  let mainIters   = col_floor / WGS;
+  let hasTail     = select(0u, 1u, col_floor < colCount);
+
+  for (var idx = wgid.x; idx < count; idx += nwg.x) {
+    let i = rangeStart + idx;
+    var acc = DD(0.0, 0.0);
+
+    for (var iter = 0u; iter < mainIters; iter++) {
+      let j = params.blockStart + lid.x + iter * WGS;
+      let aidx = select(j * params.lda + i, i * params.lda + j, params.trans == 0u);
+      let ix = j * params.incx;
+      let prod = ddMulProtected(DD(AHi[aidx], ALo[aidx]), DD(xHi[ix], xLo[ix]), lid.x);
+      acc = ddAddProtected(acc, prod, lid.x);
+    }
+
+    for (var iter = 0u; iter < hasTail; iter++) {
+      let j     = params.blockStart + col_floor + lid.x;
+      let valid = j < params.blockEnd;
+      let safeJ = select(params.blockStart, j, valid);
+      let aidx  = select(safeJ * params.lda + i, i * params.lda + safeJ, params.trans == 0u);
+      let ix    = safeJ * params.incx;
+      let prod  = ddMulProtected(DD(AHi[aidx], ALo[aidx]), DD(xHi[ix], xLo[ix]), lid.x);
+      let contribution = DD(select(0.0, prod.hi, valid), select(0.0, prod.lo, valid));
+      acc = ddAddProtected(acc, contribution, lid.x);
+    }
+
+    tile[lid.x] = acc;
+    workgroupBarrier();
+
+    // Inactive threads combine against a throwaway partner and discard it
+    // (ddAddProtected must be called unconditionally by every thread).
+    for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+      let partner = select(lid.x, lid.x + s, lid.x < s);
+      let combined = ddAddProtected(tile[lid.x], tile[partner], lid.x);
+      workgroupBarrier(); // all threads must read tile[] above before any write below
+      if (lid.x < s) { tile[lid.x] = combined; }
+      workgroupBarrier();
+    }
+
+    let ix_i = i * params.incx;
+    let xVal = DD(xHi[ix_i], xLo[ix_i]);
+    // tile[0] now holds the full subtracted term, visible to every lane —
+    // every thread redundantly finishes the O(1) subtraction so the
+    // protected op below stays uniformly called (only the write is gated).
+    let result = ddSubProtected(xVal, tile[0], lid.x);
+
+    if (lid.x == 0u) {
+      xHi[ix_i] = result.hi;
+      xLo[ix_i] = result.lo;
+    }
+    // All 64 threads must agree before the next row (grid-stride) reuses tile[].
+    workgroupBarrier();
+  }
+}

package/src/shaders/f64/utils/multiply.wgsl

@@ -84,7 +84,16 @@ fn ddMulRaw(a: DD, b: DD, threadSlot: u32) -> DD {
   return DD(p.hi, crossAndLo);
 }
 
+// A third compiler bug (Intel Mesa ANV, via NIR dump): raw.hi never gets
+// materialized as one rounded value — the driver re-fuses a.hi*b.hi with
+// ffma at every use site instead, breaking the a+b == s+e identity
+// TwoSum-style algorithms depend on. Same fix as ddMulRaw's p.lo: force it
+// through workgroup memory + a barrier. (Verified: max forward-error factor
+// over 20000 trials dropped from >1e5 to ~3-4, Intel Mesa Iris Xe + NVIDIA GTX 1650.)
 fn ddMulProtected(a: DD, b: DD, threadSlot: u32) -> DD {
   let raw = ddMulRaw(a, b, threadSlot);
-  return fastTwoSumProtected(raw.hi, raw.lo, threadSlot);
+  dekkerScratch[threadSlot] = raw.hi;
+  workgroupBarrier();
+  let rawHi = dekkerScratch[threadSlot];
+  return fastTwoSumProtected(rawHi, raw.lo, threadSlot);
 }

package/src/shaders/index.mjs

@@ -200,12 +200,75 @@ routineShaders.strsv = {
 import sger from "./sger.wgsl";
 routineShaders.sger = { sger };
 
+import dger from "./dger.wgsl"; // f64 sibling of sger — one ddMulProtected + one ddMulProtected + one ddAddProtected per element, no reduction shader needed
+routineShaders.dger = {
+  "f64/dekker": dekker,
+  "f64/utils/add": ddAddUtil,
+  "f64/utils/multiply": ddMulUtil,
+  dger,
+};
+
 import ssyr from "./ssyr.wgsl";
 routineShaders.ssyr = { ssyr };
 
+import dsyr from "./dsyr.wgsl"; // f64 sibling of ssyr — two ddMulProtected + one ddAddProtected per element, no reduction shader needed
+routineShaders.dsyr = {
+  "f64/dekker": dekker,
+  "f64/utils/add": ddAddUtil,
+  "f64/utils/multiply": ddMulUtil,
+  dsyr,
+};
+
 import ssyr2 from "./ssyr2.wgsl";
 routineShaders.ssyr2 = { ssyr2 };
 
+import dsyr2 from "./dsyr2.wgsl"; // f64 sibling of ssyr2 — two ddMulProtected + two ddAddProtected per element, no reduction shader needed
+routineShaders.dsyr2 = {
+  "f64/dekker": dekker,
+  "f64/utils/add": ddAddUtil,
+  "f64/utils/multiply": ddMulUtil,
+  dsyr2,
+};
+
+import dgemv_n from "./dgemv_n.wgsl"; // f64 sibling of sgemv_n — per-row DD dot product via a full within-workgroup tree reduction (ddot's reduction shape), not sgemv_n's 4-way ILP unroll
+import dgemv_t from "./dgemv_t.wgsl"; // f64 sibling of sgemv_t — per-thread accumulation tiled over x, with out-of-range columns computed against a clamped index (not skipped) to keep protected-op call counts uniform
+routineShaders.dgemv = {
+  "f64/dekker": dekker,
+  "f64/utils/add": ddAddUtil,
+  "f64/utils/multiply": ddMulUtil,
+  dgemv_n,
+  dgemv_t,
+}; // one or the other, picked by trans
+
+import dsymv from "./dsymv.wgsl"; // f64 sibling of ssymv — same per-row DD tree reduction as dgemv_n, with a uplo-mirror address lookup (symIdx) replacing dgemv_n's plain row-major fetch
+routineShaders.dsymv = {
+  "f64/dekker": dekker,
+  "f64/utils/add": ddAddUtil,
+  "f64/utils/multiply": ddMulUtil,
+  dsymv,
+};
+
+import dtrmv from "./dtrmv.wgsl"; // f64 sibling of strmv — per-row DD tree reduction (dsymv's shape) over a triangular, per-row-varying column range (dsyr's shape), not a mirrored or full-n one; wgblas's trmv already writes to a separate y rather than aliasing x in place, so there's no read/write-ordering concern to port
+routineShaders.dtrmv = {
+  "f64/dekker": dekker,
+  "f64/utils/add": ddAddUtil,
+  "f64/utils/multiply": ddMulUtil,
+  dtrmv,
+};
+
+import dtrsv_invert_block from "./dtrsv_invert_block.wgsl"; // f64 sibling of strsv_invert_block — same per-column substitution, but the non-unit-diagonal division is the first real ddDivProtected use in this port order (deliberately last per TODO.md)
+import dtrsv_apply_inverse from "./dtrsv_apply_inverse.wgsl"; // f64 sibling of strsv_apply_inverse — per-thread dense matvec against the block inverse, every thread runs the same blockLen-iteration loop (no early return) to keep protected-op call counts uniform
+import dtrsv_update from "./dtrsv_update.wgsl"; // f64 sibling of strsv_update — per-row DD tree reduction (dsymv's shape) over the fixed-width block column range (dger's shape, not per-row-varying)
+routineShaders.dtrsv = {
+  "f64/dekker": dekker,
+  "f64/utils/add": ddAddUtil,
+  "f64/utils/multiply": ddMulUtil,
+  "f64/utils/divide": ddDivUtil,
+  dtrsv_invert_block,
+  dtrsv_apply_inverse,
+  dtrsv_update,
+};
+
 import sgemm_small from "./sgemm_small.wgsl";
 import sgemm_large from "./sgemm_large.wgsl";
 routineShaders.sgemm = { sgemm_small, sgemm_large }; // one or the other, picked by a tile-size threshold