Add measured Hexagon NPU figures and the JIT reproduction steps

README.md

@@ -96,6 +96,70 @@ Measured on a **Pixel 8a** (Tensor G3, Android 16) with the standard TFLite [`be
 
 **The two GPU rows are different runtimes, not a contradiction.** The `LITERT_CL` figure is the one recorded when this model shipped, taken through LiteRT's own `CompiledModel` accelerator — the path the Kotlin sample app and the LiteRT API use. The `TfLiteGpuDelegateV2` figure is the classic TFLite OpenCL delegate, measured with a tool anyone can download and re-run. They agree on how much of the graph the GPU takes; they disagree on speed, and the classic delegate is the slower of the two here. Read the `TfLiteGpuDelegateV2` row as a reproducible floor, not as this model's speed on LiteRT.
 
+## Snapdragon NPU (Hexagon)
+
+This file runs on the Qualcomm Hexagon NPU **as published** — no conversion and no
+pre-compiled artifact. LiteRT compiles it on the device and caches the result.
+
+Measured on a physical **Samsung Galaxy S26** (Snapdragon 8 Elite Gen 5 / SM8850,
+Hexagon v81) with LiteRT `CompiledModel` 2.2.0 — 5 warm-up runs then 50 timed runs, one
+accelerator per process, every row taken at device thermal status `NONE`.
+
+| Compute unit | Inference (median / min) | Load | Start headroom |
+|---|---|---|---|
+| NPU (Hexagon) — first launch | 1.75 ms / 1.68 ms | 1287 ms | 0.60 |
+| NPU (Hexagon) — cached | 1.74 ms / 1.71 ms | **258 ms** | 0.60 |
+| GPU (Adreno) | 8.53 ms / 8.18 ms | 636 ms | 0.60 |
+
+The NPU is **4.9x faster** on inference here (1.74 ms against 8.53 ms). The first launch pays once for on-device compilation; every launch after that
+loads in 258 ms against 636 ms for the GPU (2.5x), because the GPU rebuilds its
+shaders each time. The file is fp16 and needs no int8 quantization to reach the NPU.
+
+### Running it on the NPU
+
+Put these in `jniLibs/arm64-v8a/`. **None of them are distributed from this repository** —
+the first two come from Google, the rest from Qualcomm's own SDK:
+
+| Library | Source |
+|---|---|
+| `libLiteRtDispatch_Qualcomm.so`, `libLiteRtCompilerPlugin_Qualcomm.so` | `litert_npu_runtime_libraries_jit.zip`, a release asset of [google-ai-edge/LiteRT](https://github.com/google-ai-edge/LiteRT/releases) |
+| `libQnnHtp.so`, `libQnnSystem.so`, `libQnnHtpV81Stub.so`, `libQnnHtpV81Skel.so`, `libQnnHtpPrepare.so`, `libQnnIr.so`, `libQnnSaver.so` | Qualcomm QAIRT — the same zip ships `fetch_qualcomm_library.sh`, which downloads the SDK and copies them for you |
+
+Pick the runtime matching the device's Hexagon version: SM8550 → v73, SM8650 → v75,
+SM8750 → v79, SM8850 → v81.
+
+```kotlin
+val env = Environment.create(
+    context,
+    mapOf(
+        Environment.Option.DispatchLibraryDir to context.applicationInfo.nativeLibraryDir,
+        // Required for on-device compilation. Without it the model silently runs on CPU.
+        Environment.Option.CompilerPluginLibraryDir to context.applicationInfo.nativeLibraryDir,
+    ),
+)
+val options = CompiledModel.Options(Accelerator.NPU).apply {
+    qualcommOptions = CompiledModel.QualcommOptions(
+        htpPerformanceMode = CompiledModel.QualcommOptions.HtpPerformanceMode.BURST
+    )
+}
+val model = CompiledModel.create(context.assets, "6drepnet.tflite", options, env)
+```
+
+Build settings: `useLegacyPackaging = true` under `packaging { jniLibs { … } }`, so the
+DSP can open the skel from a real path, and Kotlin **2.3+** for LiteRT 2.2.0's metadata.
+
+> **Every NPU failure here is silent.** There is no error when the NPU is unavailable —
+> you get a plausible CPU number instead. Confirm from logcat which delegate took the
+> graph: `Replacing 1 out of 1 node(s) with delegate (DispatchDelegate)` is the NPU,
+> while `... (TfLiteXNNPackDelegate)` is the CPU. A missing library is reported only as
+> a `W`-level `dlopen failed` line under a generic `No compiler plugin found` summary.
+
+**On the conditions.** Thermal headroom is reported as measured, where 1.0 is the
+throttling threshold. All rows were taken at a comparable headroom and compare directly;
+figures taken at a different headroom will differ. Each accelerator ran in its own
+process, because LiteRT's `Environment` is shared within one and the first model load
+fixes the options for every later one.
+
 ## License
 
 MIT (6DRepNet / thohemp). Trained on 300W-LP.