feat(distributed): add packed hybrid runtime and THD planner

README.md

@@ -146,6 +146,9 @@ print(f'Final state shape: {final_state.shape}')  # [2, 32, 128, 128]
 See [USAGE.md](USAGE.md) for detailed usage examples and notes.
 See [the standalone kernel inventory](docs/KERNEL_VALUE.md) for the public
 kernel boundary and the overlap assessment against FlashInfer and cuDNN.
+The optional [cuDNN hybrid-attention runtime](docs/HYBRID_CUDNN_RUNTIME.md)
+documents packed index pooling, memory-bounded DSA selection, and CP layout
+ownership without precision downgrades.
 
 ## Benchmarks
 

REPO_LAYOUT.md

@@ -21,6 +21,10 @@ cuLA/
 │   ├── distributed/                   # Optional cuDNN KDA Kimi CP runtime
 │   │   ├── plan.py                    # CPU-only packed-THD boundary planning
 │   │   └── kda.py                     # Collectives and distributed autograd
+│   ├── hybrid/                        # Layout-aware cuDNN hybrid-attention runtime
+│   │   ├── index_pool.py              # Differentiable CSA index pooling
+│   │   ├── dsa.py                     # Bounded packed-THD DSA block selection
+│   │   └── plan.py                    # CP block ownership and seam-halo plans
 │   │
 │   ├── lightning/                     # [non-KDA] Lightning Attention public wrappers
 │   │
@@ -48,6 +52,13 @@ cuLA/
 │       └── experimental/               # [non-KDA] unwired prototypes
 │
 ├── benchmarks/                         # Accuracy and performance runners
+│   └── large_cp_emulation/             # Logical CP-on-fewer-GPUs simulation layer
+│       ├── topology.py                 # Logical/physical rank separation
+│       ├── transport.py                # Native-CP protocol cost emulation
+│       ├── workload.py                 # Packed-THD workload descriptions
+│       ├── bench_components.py         # DSA and ring microbenchmarks
+│       ├── bench_kda.py                # KDA logical-CP E2E
+│       └── bench_hybrid.py             # KDA + DSA serial/overlap E2E
 ├── tests/                              # CPU registry tests and architecture-marked GPU tests
 ├── docs/                               # Pipeline and backend-dispatch design notes
 ├── scripts/build_wheel.sh
@@ -61,6 +72,8 @@ cuLA/
 |-----------|----------|-------------|
 | `cula/kernels/` | Python | Framework-independent public surface and static kernel inventory. Imports are lazy and do not compile kernels. |
 | `cula/kda/` | Python / CuTeDSL | KDA prefill/decode wrappers and the pure-CuTeDSL SM100 modular composition. `kda_prefill` calls FlashKDA directly without a native fallback. See [`cula/kda/README.md`](cula/kda/README.md). |
+| `cula/hybrid/` | Python | Optional cuDNN-backed composition layer for packed index pooling, bounded DSA selection, and CP layout planning. See [`docs/HYBRID_CUDNN_RUNTIME.md`](docs/HYBRID_CUDNN_RUNTIME.md). |
+| `benchmarks/large_cp_emulation/` | Python | Benchmark-only logical-CP layer built on the native `cula.distributed` and `cula.hybrid` APIs; it never participates in production imports. |
 | `cula/ops/kda/` | Python (CuTeDSL) | CuTeDSL KDA kernels organized into SM100 modular kernels, SM90 FlashKDA K1+K2 and intracard CP, decode, and experimental code. |
 | `cula/ops/lightning/` · `cula/ops/experimental/` | Python (CuTeDSL) | `[non-KDA]` Lightning/linear-attention kernels and prototypes. Lightning prefill dispatches to the SM90 or SM100 backend from Q's device capability. |
 | `cula/ops/{inv,ptx}.py` · `cula/ops/sm100/ptx.py` | Python | Shared low-level helpers used across operators. |

USAGE.md

@@ -4,6 +4,21 @@ This document provides usage notes and examples for cuLA kernels.
 
 ---
 
+## cuDNN hybrid index pooling and DSA selection
+
+The optional hybrid runtime preserves packed THD layouts between cuDNN index
+pooling and DSA selection. It owns static metadata and bounded scratch, while
+cuDNN owns the fused kernels and precision contract. Install it with:
+
+```bash
+pip install 'cuda-linear-attention[cudnn-hybrid]'
+```
+
+See [`docs/HYBRID_CUDNN_RUNTIME.md`](docs/HYBRID_CUDNN_RUNTIME.md) for the API,
+128K heterogeneous/CP4 measurements, and current implementation boundary.
+
+---
+
 ## cuDNN KDA Kimi context parallelism
 
 The optional distributed runtime executes cuDNN KDA over contiguous packed-THD

benchmarks/bench_hybrid_cp_emulation.py

@@ -0,0 +1,18 @@
+# Copyright 2025-2026 Ant Group Co., Ltd.
+# SPDX-License-Identifier: Apache-2.0
+# ruff: noqa: E402, I001
+
+"""Compatibility entry point for large-CP component emulation."""
+
+from __future__ import annotations
+
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
+
+from benchmarks.large_cp_emulation.bench_components import main
+
+
+if __name__ == "__main__":
+    main()

benchmarks/bench_hybrid_kda_dsa_e2e.py

@@ -0,0 +1,18 @@
+# Copyright 2025-2026 Ant Group Co., Ltd.
+# SPDX-License-Identifier: Apache-2.0
+# ruff: noqa: E402, I001
+
+"""Compatibility entry point for the large-CP hybrid emulator."""
+
+from __future__ import annotations
+
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
+
+from benchmarks.large_cp_emulation.bench_hybrid import main
+
+
+if __name__ == "__main__":
+    main()