Mamba-3 (real algorithm) kernel-level PoC — Stages A–C complete

.gitignore

@@ -3,9 +3,10 @@
 ##
 ## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
 
-# Claude Code local config (machine-specific paths, agent memory)
+# Claude Code local config (machine-specific paths, agent memory, session lock)
 .claude/local-paths.md
 .claude/agent-memory/
+.claude/scheduled_tasks.lock
 
 # User-specific files
 *.rsuser
@@ -425,3 +426,12 @@ FodyWeavers.xsd
 
 # dotLLM test model cache
 tests/.models/
+
+# Scratch files used during nemotron_h research (do not commit)
+_*.cpp
+_*.txt
+.mamba3-reference/
+.mamba3-reference-canonical/
+.mamba3-python-venv/
+.venv-pyref/
+.gpu-lock/

.perf-runs/cross-lib-20260424-expA/README.md

@@ -0,0 +1,61 @@
+---
+date: 2026-04-24
+experiment: A — clamp _decodeThreadCount to min(8, threadCount) when no NumaTopology
+baseline: .perf-runs/cross-lib-20260424/ (dotLLM at 8.66 tok/s, 22.17 s wall)
+---
+
+## Result
+
+Same harness, same model, same prompt, same host — only change is the
+one-line decode-thread-count clamp in `ComputeThreadPool`:
+
+| Backend | Run | tok/s | wall (s) |
+|---|---|---:|---:|
+| llama.cpp CPU (`-ngl 0`, from baseline) | 1 | 34.73 | 5.53 |
+| dotLLM CPU (pre-experiment, from baseline) | 1 | **8.66** | 22.17 |
+| dotLLM CPU + experiment A (cold) | 1 | **33.76** | 5.69 |
+| dotLLM CPU + experiment A (warm prefix cache) | 2 | 39.03 | 4.92 |
+| dotLLM CPU + experiment A (warm prefix cache) | 3 | 39.64 | 4.84 |
+
+First-run / cold comparison: **dotLLM 33.76 vs llama.cpp 34.73 — within 3%**.
+The 4× gap reported in the previous cross-lib comparison collapses to noise.
+
+## What changed
+
+One default, in `src/DotLLM.Cpu/Threading/ComputeThreadPool.cs`:
+
+```diff
+- : threadCount;
++ : Math.Clamp(DefaultDecodeThreadCountCap /* = 8 */, 2, threadCount);
+```
+
+When the pool is built without a `NumaTopology`, `_decodeThreadCount` used
+to fall back to `threadCount`, so SpinWait mode ran all 31 workers on a
+32-thread host. The `ThreadPoolDispatchBenchmarks` microbench (see
+`.perf-runs/cross-lib-20260424/dispatch-microbench.md`) showed that path
+collapses: Dispatch(no-op) costs 333 µs at 32T SpinWait vs 1 µs at 8T,
+driven by 31 threads hammering one cache line on `_dispatchGeneration`
+and a contended `_completion.Signal()` decrement.
+
+Capping to 8 keeps SpinWait in the regime the microbench shows scales
+well (2–16 threads, sub-µs dispatch cost). Prefill still uses all 32
+threads via EventBased mode — unaffected.
+
+## Why 8
+
+Matches the heuristic already applied when a `NumaTopology` *is*
+provided: `topology.MemoryChannelEstimate` (typically 2 channels × 4 on
+Zen 5 desktop/workstation = 8). Decode is memory-bandwidth bound, not
+compute bound, so extra concurrent loads past a small multiple of memory
+channels add cache-line contention without adding useful bandwidth.
+
+## Next
+
+The 3% residual gap vs llama.cpp is within benchmark noise. If we want
+to push past llama.cpp on this workload, the remaining levers in
+priority order are the ones already listed in
+`.perf-runs/cross-lib-20260424/dispatch-microbench.md` §Concrete next-step
+experiments B and C (size-gated single-threaded fast path, cache-line
+padding in `ComputeThreadPool`). Neither is currently justified by the
+numbers — come back to them if we regress or if we see a similar issue
+on a host with different topology.

.perf-runs/cross-lib-20260424-expA/dotllm-throughput-2.json

@@ -0,0 +1,52 @@
+{
+  "benchmark": "throughput_openai",
+  "run_started_at": "2026-04-24T16:48:19.500009+00:00",
+  "run_finished_at": "2026-04-24T16:48:25.691817+00:00",
+  "output_path": "C:\\Development\\dotLLM-mamba3\\.perf-runs\\cross-lib-20260424-expA\\dotllm-throughput-2.json",
+  "base_url": "http://127.0.0.1:8000",
+  "host_details": {
+    "captured_at": "2026-04-24T16:48:20.557529+00:00",
+    "hostname": "Strix",
+    "host_slug": "strix",
+    "os": {
+      "system": "Windows",
+      "release": "11",
+      "version": "10.0.26200",
+      "machine": "AMD64"
+    },
+    "manufacturer": "Bosgame",
+    "model": "BeyondMax Series",
+    "processor": "AMD64 Family 26 Model 112 Stepping 0, AuthenticAMD",
+    "logical_cpu_count": 32,
+    "total_memory_gb": 63.65,
+    "python_version": "3.12.10",
+    "ollama_version": "Warning: could not connect to a running Ollama instance",
+    "gpus": [
+      {
+        "Name": "AMD Radeon(TM) 8060S Graphics",
+        "AdapterRAM": 4293918720,
+        "DriverVersion": "32.0.12064.27",
+        "VideoProcessor": "AMD Radeon Graphics Processor (0x1586)",
+        "Status": "OK"
+      }
+    ]
+  },
+  "models": [
+    "SmolLM-135M"
+  ],
+  "results": [
+    {
+      "model": "SmolLM-135M",
+      "completion_tokens": 192,
+      "toks_per_s": 39.03,
+      "total_s": 4.92,
+      "cpu_avg_pct": 0,
+      "cpu_peak_pct": 0,
+      "ram_peak_gb": 0.71,
+      "gpu_util_avg": 25.5,
+      "gpu_util_peak": 25.5,
+      "gpu_mem_peak_gb": 3.33,
+      "response_preview": "Write a concise explanation of dependency injection with one short Python example.\n\n## 1.1.1. Introduction\n\nDependency injection is a technique that allows you to write a single unit of code that can "
+    }
+  ]
+}

.perf-runs/cross-lib-20260424-expA/dotllm-throughput-3.json

@@ -0,0 +1,52 @@
+{
+  "benchmark": "throughput_openai",
+  "run_started_at": "2026-04-24T16:48:31.857488+00:00",
+  "run_finished_at": "2026-04-24T16:48:37.834574+00:00",
+  "output_path": "C:\\Development\\dotLLM-mamba3\\.perf-runs\\cross-lib-20260424-expA\\dotllm-throughput-3.json",
+  "base_url": "http://127.0.0.1:8000",
+  "host_details": {
+    "captured_at": "2026-04-24T16:48:32.801487+00:00",
+    "hostname": "Strix",
+    "host_slug": "strix",
+    "os": {
+      "system": "Windows",
+      "release": "11",
+      "version": "10.0.26200",
+      "machine": "AMD64"
+    },
+    "manufacturer": "Bosgame",
+    "model": "BeyondMax Series",
+    "processor": "AMD64 Family 26 Model 112 Stepping 0, AuthenticAMD",
+    "logical_cpu_count": 32,
+    "total_memory_gb": 63.65,
+    "python_version": "3.12.10",
+    "ollama_version": "Warning: could not connect to a running Ollama instance",
+    "gpus": [
+      {
+        "Name": "AMD Radeon(TM) 8060S Graphics",
+        "AdapterRAM": 4293918720,
+        "DriverVersion": "32.0.12064.27",
+        "VideoProcessor": "AMD Radeon Graphics Processor (0x1586)",
+        "Status": "OK"
+      }
+    ]
+  },
+  "models": [
+    "SmolLM-135M"
+  ],
+  "results": [
+    {
+      "model": "SmolLM-135M",
+      "completion_tokens": 192,
+      "toks_per_s": 39.64,
+      "total_s": 4.844,
+      "cpu_avg_pct": 0,
+      "cpu_peak_pct": 0,
+      "ram_peak_gb": 0.71,
+      "gpu_util_avg": 21.5,
+      "gpu_util_peak": 21.5,
+      "gpu_mem_peak_gb": 3.33,
+      "response_preview": "Write a concise explanation of dependency injection with one short Python example.\n\n## 1.1.1. Introduction\n\nDependency injection is a technique that allows you to write a single unit of code that can "
+    }
+  ]
+}

.perf-runs/cross-lib-20260424-expA/dotllm-throughput.json

@@ -0,0 +1,52 @@
+{
+  "benchmark": "throughput_openai",
+  "run_started_at": "2026-04-24T16:48:01.079631+00:00",
+  "run_finished_at": "2026-04-24T16:48:09.358730+00:00",
+  "output_path": "C:\\Development\\dotLLM-mamba3\\.perf-runs\\cross-lib-20260424-expA\\dotllm-throughput.json",
+  "base_url": "http://127.0.0.1:8000",
+  "host_details": {
+    "captured_at": "2026-04-24T16:48:02.358822+00:00",
+    "hostname": "Strix",
+    "host_slug": "strix",
+    "os": {
+      "system": "Windows",
+      "release": "11",
+      "version": "10.0.26200",
+      "machine": "AMD64"
+    },
+    "manufacturer": "Bosgame",
+    "model": "BeyondMax Series",
+    "processor": "AMD64 Family 26 Model 112 Stepping 0, AuthenticAMD",
+    "logical_cpu_count": 32,
+    "total_memory_gb": 63.65,
+    "python_version": "3.12.10",
+    "ollama_version": "Warning: could not connect to a running Ollama instance",
+    "gpus": [
+      {
+        "Name": "AMD Radeon(TM) 8060S Graphics",
+        "AdapterRAM": 4293918720,
+        "DriverVersion": "32.0.12064.27",
+        "VideoProcessor": "AMD Radeon Graphics Processor (0x1586)",
+        "Status": "OK"
+      }
+    ]
+  },
+  "models": [
+    "SmolLM-135M"
+  ],
+  "results": [
+    {
+      "model": "SmolLM-135M",
+      "completion_tokens": 192,
+      "toks_per_s": 33.76,
+      "total_s": 5.686,
+      "cpu_avg_pct": 0,
+      "cpu_peak_pct": 0,
+      "ram_peak_gb": 0.7,
+      "gpu_util_avg": 27.9,
+      "gpu_util_peak": 27.9,
+      "gpu_mem_peak_gb": 3.33,
+      "response_preview": "Write a concise explanation of dependency injection with one short Python example.\n\n## 1.1.1. Introduction\n\nDependency injection is a technique that allows you to write a single unit of code that can "
+    }
+  ]
+}

.perf-runs/cross-lib-20260424-expA/throughput-resource-SmolLM-135M.json

@@ -0,0 +1,52 @@
+{
+  "benchmark": "throughput_openai",
+  "run_started_at": "2026-04-24T16:48:31.857488+00:00",
+  "run_finished_at": "2026-04-24T16:48:37.835576+00:00",
+  "output_path": "C:\\Development\\dotLLM-mamba3\\.perf-runs\\cross-lib-20260424-expA\\throughput-resource-SmolLM-135M.json",
+  "base_url": "http://127.0.0.1:8000",
+  "host_details": {
+    "captured_at": "2026-04-24T16:48:32.801487+00:00",
+    "hostname": "Strix",
+    "host_slug": "strix",
+    "os": {
+      "system": "Windows",
+      "release": "11",
+      "version": "10.0.26200",
+      "machine": "AMD64"
+    },
+    "manufacturer": "Bosgame",
+    "model": "BeyondMax Series",
+    "processor": "AMD64 Family 26 Model 112 Stepping 0, AuthenticAMD",
+    "logical_cpu_count": 32,
+    "total_memory_gb": 63.65,
+    "python_version": "3.12.10",
+    "ollama_version": "Warning: could not connect to a running Ollama instance",
+    "gpus": [
+      {
+        "Name": "AMD Radeon(TM) 8060S Graphics",
+        "AdapterRAM": 4293918720,
+        "DriverVersion": "32.0.12064.27",
+        "VideoProcessor": "AMD Radeon Graphics Processor (0x1586)",
+        "Status": "OK"
+      }
+    ]
+  },
+  "models": [
+    "SmolLM-135M"
+  ],
+  "results": [
+    {
+      "model": "SmolLM-135M",
+      "completion_tokens": 192,
+      "toks_per_s": 39.64,
+      "total_s": 4.844,
+      "cpu_avg_pct": 0,
+      "cpu_peak_pct": 0,
+      "ram_peak_gb": 0.71,
+      "gpu_util_avg": 21.5,
+      "gpu_util_peak": 21.5,
+      "gpu_mem_peak_gb": 3.33,
+      "response_preview": "Write a concise explanation of dependency injection with one short Python example.\n\n## 1.1.1. Introduction\n\nDependency injection is a technique that allows you to write a single unit of code that can "
+    }
+  ]
+}