perf(engine/metal): ICB go/no-go instrument — phase 3 CLOSED by rule (#341)

ICB commands within one executeCommandsInBuffer are concurrent-typed (no
ordering inside an execute), so a dependent per-layer chain recorded as
an ICB must issue one execute per stage. TestHopTaxICBMicrobench
measures that shape: a DEPENDENT execute on a serial encoder costs
9.76us/hop on this hardware — 2.4x the 4.13us barrier hop the carried
concurrent encoder already pays — while the ICB concurrency ceiling for
independent bundles is 0.52us/dispatch (which is what the dense lane
correctly uses ICBs for).

Pre-registered rule fires: a stage-ICB MoE decode would REGRESS the 26B,
and the host-encode elimination ICBs classically buy is already hidden
by submit-ahead (0.17 ms/token host/sync gap). The stale
router-readback premise is retired a different way than expected: the
prerequisites all landed, and the measurement says the destination is
not worth the trip. This also explains the dense/E-family lanes sharing
the same ~110us/layer floor despite their ICB path — dependent executes
pay the same drain.

Co-Authored-By: Virgil <virgil@lethean.io>

Author: Snider

go/engine/metal/hop_tax_test.go

@@ -9,6 +9,7 @@ import (
 	"time"
 	"unsafe"
 
+	"github.com/tmc/apple/foundation"
 	"github.com/tmc/apple/metal"
 )
 
@@ -204,3 +205,86 @@ func TestHopTaxMicrobench(t *testing.T) {
 		t.Fatal("dependent chain measured no GPU time — the bench is broken")
 	}
 }
+
+// TestHopTaxICBMicrobench is the phase-3 go/no-go instrument (#341): ICB
+// commands within one executeCommandsInBuffer are CONCURRENT-typed (no
+// ordering inside an execute), so a dependent per-layer chain recorded as an
+// ICB must issue one execute per stage — the decisive constant is therefore
+// the cost of a DEPENDENT execute on a serial encoder, against the carried
+// concurrent encoder's 4.13µs barrier hop (the shape the decode already runs).
+//
+// Pre-registered rule: dependent-execute ≥ the barrier hop ⇒ a stage-ICB MoE
+// decode buys nothing GPU-side (and submit-ahead already hides the host
+// encode) ⇒ phase 3 closes by rule. Only a dramatically cheaper execute
+// (< ~2µs) earns the build.
+func TestHopTaxICBMicrobench(t *testing.T) {
+	requireNativeRuntime(t)
+	const dModel = 2816
+	const n = 512
+	eps := float32(1e-6)
+
+	rmsPSO, err := pipelineForICB(rmsKernelBF16(dModel))
+	if err != nil {
+		t.Skipf("ICB-capable rms pipeline unavailable: %v", err)
+	}
+	rmsTG := rmsThreadgroup(dModel, rmsPSO)
+
+	w := toBF16Bytes(syntheticFloat32(dModel, 7))
+	wBuf := device.NewBufferWithBytesLengthOptions(unsafe.Pointer(&w[0]), uint(len(w)), metal.MTLResourceStorageModeShared)
+	ping := device.NewBufferWithLengthOptions(uint(dModel*bf16Size), metal.MTLResourceStorageModeShared)
+	pong := device.NewBufferWithLengthOptions(uint(dModel*bf16Size), metal.MTLResourceStorageModeShared)
+	indepOut := device.NewBufferWithLengthOptions(uint(n*dModel*bf16Size), metal.MTLResourceStorageModeShared)
+
+	icbDesc := metal.NewMTLIndirectCommandBufferDescriptor()
+	icbDesc.SetCommandTypes(metal.MTLIndirectCommandTypeConcurrentDispatch)
+	icbDesc.SetInheritBuffers(false)
+	icbDesc.SetInheritPipelineState(false)
+	icbDesc.SetMaxKernelBufferBindCount(8)
+
+	// dependent chain: command i reads the previous command's output (ping↔pong),
+	// replayed as n SEPARATE executes so the serial encoder orders them.
+	depICB := device.NewIndirectCommandBufferWithDescriptorMaxCommandCountOptions(icbDesc, uint(n), metal.MTLResourceStorageModeShared)
+	a, b := ping, pong
+	for i := 0; i < n; i++ {
+		cmd := indirectComputeCommandAtIndexFast(depICB, uint(i))
+		emitRMSNorm(fastICBSink{cmd}, rmsPSO, a, wBuf, b, 0, dModel, eps, rmsTG)
+		a, b = b, a
+	}
+	// independent: n commands with disjoint outputs, ONE execute (the ICB's
+	// internal concurrency ceiling).
+	indepICB := device.NewIndirectCommandBufferWithDescriptorMaxCommandCountOptions(icbDesc, uint(n), metal.MTLResourceStorageModeShared)
+	for i := 0; i < n; i++ {
+		cmd := indirectComputeCommandAtIndexFast(indepICB, uint(i))
+		emitRMSNormAt(fastICBSink{cmd}, rmsPSO, ping, wBuf, indepOut, 0, 0, uint(i*dModel*bf16Size), dModel, eps, rmsTG)
+	}
+
+	resident := []metal.MTLResource{wBuf, ping, pong, indepOut}
+	residentIDs := resourceIDsForFastUse(nil, resident)
+	empty := hopTaxTime(t, func(cb metal.MTLCommandBufferObject) {})
+
+	depExec := hopTaxTime(t, func(cb metal.MTLCommandBufferObject) {
+		enc := computeCommandEncoderFast(cb)
+		useResourcesIDsFast(enc, resident, residentIDs, metal.MTLResourceUsageRead|metal.MTLResourceUsageWrite)
+		for i := 0; i < n; i++ {
+			executeCommandsInBufferWithRangeFast(enc, depICB, foundation.NSRange{Location: uint(i), Length: 1})
+		}
+		endEncodingFast(enc)
+	})
+	oneExec := hopTaxTime(t, func(cb metal.MTLCommandBufferObject) {
+		enc := computeCommandEncoderFast(cb)
+		useResourcesIDsFast(enc, resident, residentIDs, metal.MTLResourceUsageRead|metal.MTLResourceUsageWrite)
+		executeCommandsInBufferWithRangeFast(enc, indepICB, foundation.NSRange{Location: 0, Length: uint(n)})
+		endEncodingFast(enc)
+	})
+
+	per := func(d time.Duration, count int) float64 {
+		net := d - empty
+		if net < 0 {
+			net = 0
+		}
+		return float64(net.Nanoseconds()) / 1e3 / float64(count)
+	}
+	t.Logf("ICB rms %d-wide, n=%d:", dModel, n)
+	t.Logf("  dependent, one execute per hop (serial enc): %7.2f µs/hop   — compare the 4.13µs barrier hop", per(depExec, n))
+	t.Logf("  independent, ONE execute of %d commands:     %7.2f µs/dispatch — the ICB concurrency ceiling", n, per(oneExec, n))
+}