feat(moe): add heterogeneous NVMe expert streaming tier

.github/workflows/ci.yml

@@ -79,12 +79,15 @@ jobs:
             -DCMAKE_BUILD_TYPE=Release
           cmake --build build --target \
             test_dflash test_generate test_flash_attn_sparse test_server_unit \
-            test_deepseek4_unit -j$(nproc)
+            test_deepseek4_unit test_moe_nvme_scheduler \
+            test_moe_expert_package -j$(nproc)
 
       - name: Run C++ server unit tests
         run: |
           cd server/build
-          ctest --output-on-failure -R "server_unit|deepseek4_unit" --no-tests=error
+          ctest --output-on-failure \
+            -R "server_unit|deepseek4_unit|test_moe_nvme_scheduler|test_moe_expert_package" \
+            --no-tests=error
 
       - name: Populate venv with cu128 torch + setuptools
         # First pass: install the workspace's default deps. dflash declares
@@ -174,6 +177,8 @@ jobs:
             -DCMAKE_BUILD_TYPE=Release
           cmake --build build \
             --target test_flash_attn_sparse test_deepseek4_mmid_grouped_cuda \
+              test_moe_stream_compute test_moe_nvme_scheduler \
+              test_moe_expert_package \
             -j"$(nproc)"
 
       - name: Run flash-attn sparse kernel test on the 3090
@@ -184,6 +189,14 @@ jobs:
       - name: Run grouped MMID dispatch and parity test on the 3090
         run: ./server/build/test_deepseek4_mmid_grouped_cuda
 
+      - name: Run compact-to-padded MXFP4 expert streaming test on the 3090
+        run: ./server/build/test_moe_stream_compute
+
+      - name: Run NVMe scheduler production tests
+        run: |
+          ./server/build/test_moe_nvme_scheduler
+          ./server/build/test_moe_expert_package
+
       # Optional model-backed end-to-end smoke (real spec-decode on the 3090),
       # disabled by default because it builds dflash_server and lazy-loads the
       # ~16 GB Qwen3.6-27B target + draft (~1-2 min). The weights are already
@@ -290,11 +303,13 @@ jobs:
             -DCMAKE_HIP_FLAGS=-DDFLASH_WAVE_SIZE=32
           cmake --build "$RUNNER_TEMP/rocmfp-build" \
             --target test_rocmfp4 test_rocmfpx test_rocmfp4_hip_tail test_rocmfpx_mmq \
-              test_deepseek4_mmid_grouped_cuda test_recurrent_snapshot test_server_unit \
+              test_deepseek4_mmid_grouped_cuda test_moe_stream_compute \
+              test_moe_nvme_scheduler test_moe_expert_package \
+              test_recurrent_snapshot test_server_unit \
             --parallel 8
           ctest --test-dir "$RUNNER_TEMP/rocmfp-build" \
             --output-on-failure \
-            -R 'rocmfp4_reference|rocmfpx_reference|rocmfp4_hip_tail|rocmfpx_mmq|deepseek4_mmid_grouped_cuda|recurrent_snapshot|ChainRollbackPolicy'
+            -R 'rocmfp4_reference|rocmfpx_reference|rocmfp4_hip_tail|rocmfpx_mmq|deepseek4_mmid_grouped_cuda|test_moe_stream_compute|test_moe_nvme_scheduler|test_moe_expert_package|recurrent_snapshot|ChainRollbackPolicy'
 
   build-windows:
     name: Build Windows (MSVC + CUDA, library + server targets)

server/CMakeLists.txt

@@ -364,6 +364,7 @@ set(DFLASH27B_SRC_INCLUDE_DIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/src/qwen3
     ${CMAKE_CURRENT_SOURCE_DIR}/src/gemma4
     ${CMAKE_CURRENT_SOURCE_DIR}/src/deepseek4
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/kimi_k3
     ${CMAKE_CURRENT_SOURCE_DIR}/src/server
 )
 
@@ -396,6 +397,10 @@ add_library(dflash_common STATIC
     src/deepseek4/deepseek4_target_shard_ipc_daemon.cpp
     src/deepseek4/deepseek4_dspark.cpp
     src/deepseek4/deepseek4_dspark_spec.cpp
+    # Kimi-K3 hybrid KDA/MLA + latent-MoE target arch
+    src/kimi_k3/kimi_k3_loader.cpp
+    src/kimi_k3/kimi_k3_graph.cpp
+    src/kimi_k3/kimi_k3_backend.cpp
     src/flashprefill_q8.cpp
     src/kv_cache.cpp
     src/kv_quant.cpp
@@ -434,6 +439,9 @@ add_library(dflash_common STATIC
     src/common/moe_hybrid_storage.cpp
     src/common/spark_corpus.cpp
     src/common/moe_hybrid_ffn_eval.cpp
+    src/common/moe_nvme_scheduler.cpp
+    src/common/moe_expert_package.cpp
+    src/common/moe_stream_cache_policy.cpp
     src/common/moe_hybrid_stream.cpp
     src/common/moe_expert_compute.cpp
     src/common/moe_expert_compute_cpu.cpp
@@ -757,6 +765,10 @@ target_link_libraries(dflash_common
         ggml-base
         nlohmann_json::nlohmann_json
 )
+# The NVMe scheduler uses a bounded worker pool on platforms where io_uring is
+# unavailable (and as its portable fallback).
+find_package(Threads REQUIRED)
+target_link_libraries(dflash_common PUBLIC Threads::Threads)
 # OpenMP for parallel MoE expert compute kernel (saturate memory bandwidth).
 find_package(OpenMP)
 if(OpenMP_CXX_FOUND)
@@ -806,6 +818,107 @@ if(DFLASH27B_TESTS)
         add_test(NAME platform_compat COMMAND test_platform_compat)
     endif()
 
+    # SSD scheduling is deliberately independent of ggml and the GPU runtime.
+    # Keep its correctness tests lightweight so queueing/cache invariants are
+    # exercised even on CPU-only CI workers.
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/test_moe_nvme_scheduler.cpp")
+        add_executable(test_moe_nvme_scheduler
+            test/test_unit_main.cpp
+            test/test_moe_nvme_scheduler.cpp
+            src/common/moe_nvme_scheduler.cpp)
+        target_include_directories(test_moe_nvme_scheduler PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/common
+            ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/ggml/include)
+        target_link_libraries(test_moe_nvme_scheduler PRIVATE Threads::Threads)
+        list(APPEND _raw_unit_test_targets test_moe_nvme_scheduler)
+    endif()
+
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/test_moe_expert_package.cpp")
+        add_executable(test_moe_expert_package
+            test/test_unit_main.cpp
+            test/test_moe_expert_package.cpp
+            src/common/moe_expert_package.cpp
+            src/common/moe_nvme_scheduler.cpp)
+        target_include_directories(test_moe_expert_package PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/common
+            ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/ggml/include)
+        target_link_libraries(test_moe_expert_package PRIVATE Threads::Threads)
+        list(APPEND _raw_unit_test_targets test_moe_expert_package)
+    endif()
+
+    # Read-only microbenchmark for tuning the exact expert I/O path on the
+    # deployment SSD. It accepts any sufficiently large file; no model parser
+    # or generated benchmark data is required.
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/bench_moe_nvme_io.cpp")
+        add_executable(bench_moe_nvme_io
+            test/bench_moe_nvme_io.cpp
+            src/common/moe_nvme_scheduler.cpp)
+        target_include_directories(bench_moe_nvme_io PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/common
+            ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/ggml/include)
+        target_link_libraries(bench_moe_nvme_io PRIVATE Threads::Threads)
+    endif()
+
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/bench_moe_nvme_pipeline.cpp")
+        add_executable(bench_moe_nvme_pipeline test/bench_moe_nvme_pipeline.cpp)
+        target_include_directories(bench_moe_nvme_pipeline PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/common
+            ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/ggml/include)
+        target_link_libraries(bench_moe_nvme_pipeline PRIVATE
+            dflash_common ggml ${DFLASH27B_GGML_BACKEND_TARGET})
+        if(DFLASH27B_GPU_BACKEND STREQUAL "cuda")
+            target_link_libraries(bench_moe_nvme_pipeline PRIVATE CUDA::cudart)
+        else()
+            target_link_libraries(bench_moe_nvme_pipeline PRIVATE hip::host)
+        endif()
+    endif()
+
+    # End-to-end numerical check for the reusable streamed-expert graph. It
+    # uses tiny generated F32 experts and defaults to GPU 0, so a Strix-only
+    # machine can run it without any model download. DFLASH_TEST_GPU selects a
+    # different device on multi-GPU qualification hosts.
+    if(UNIX AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/test_moe_stream_compute.cpp")
+        add_executable(test_moe_stream_compute
+            test/test_unit_main.cpp
+            test/test_moe_stream_compute.cpp)
+        target_include_directories(test_moe_stream_compute PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/common
+            ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/ggml/include
+            ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/ggml/src)
+        target_link_libraries(test_moe_stream_compute PRIVATE
+            dflash_common ggml ${DFLASH27B_GGML_BACKEND_TARGET})
+        if(DFLASH27B_GPU_BACKEND STREQUAL "cuda")
+            target_link_libraries(test_moe_stream_compute PRIVATE CUDA::cudart)
+        else()
+            target_link_libraries(test_moe_stream_compute PRIVATE hip::host)
+        endif()
+        list(APPEND _raw_unit_test_targets test_moe_stream_compute)
+    endif()
+
+    # Kimi-K3 routed-core qualification. This replays the exact latent-expert
+    # geometry (IQ1_S, 3584 -> 3072 -> 3584, SiTU) through the common NVMe
+    # stream engine. It is deliberately independent of a Kimi model loader so
+    # the hardware path can be qualified before downloading the 594 GB model.
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/bench_kimi_k3_hetero.cpp")
+        add_executable(bench_kimi_k3_hetero test/bench_kimi_k3_hetero.cpp)
+        target_include_directories(bench_kimi_k3_hetero PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/common
+            ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/ggml/include)
+        target_link_libraries(bench_kimi_k3_hetero PRIVATE
+            dflash_common ggml ${DFLASH27B_GGML_BACKEND_TARGET})
+        if(DFLASH27B_GPU_BACKEND STREQUAL "cuda")
+            target_link_libraries(bench_kimi_k3_hetero PRIVATE CUDA::cudart)
+        else()
+            target_link_libraries(bench_kimi_k3_hetero PRIVATE hip::host)
+        endif()
+    endif()
+
     if(DFLASH27B_GPU_BACKEND STREQUAL "hip"
        AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/test_cuda_pool_shutdown.cpp")
         add_executable(test_cuda_pool_shutdown
@@ -1056,6 +1169,17 @@ if(DFLASH27B_TESTS)
         target_include_directories(smoke_qwen3_forward PRIVATE ${DFLASH27B_SRC_INCLUDE_DIRS})
         target_link_libraries(smoke_qwen3_forward PRIVATE dflash_common ggml ${DFLASH27B_GGML_BACKEND_TARGET})
     endif()
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/smoke_kimi_k3_forward.cpp")
+        add_executable(smoke_kimi_k3_forward test/smoke_kimi_k3_forward.cpp)
+        target_include_directories(smoke_kimi_k3_forward PRIVATE ${DFLASH27B_SRC_INCLUDE_DIRS})
+        target_link_libraries(smoke_kimi_k3_forward PRIVATE
+            dflash_common ggml ${DFLASH27B_GGML_BACKEND_TARGET})
+        if(DFLASH27B_GPU_BACKEND STREQUAL "cuda")
+            target_link_libraries(smoke_kimi_k3_forward PRIVATE CUDA::cudart)
+        else()
+            target_link_libraries(smoke_kimi_k3_forward PRIVATE hip::host)
+        endif()
+    endif()
     if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/test_vs_oracle.cpp")
         add_executable(test_vs_oracle test/test_vs_oracle.cpp)
         target_include_directories(test_vs_oracle PRIVATE ${DFLASH27B_SRC_INCLUDE_DIRS})
@@ -1235,6 +1359,8 @@ if(DFLASH27B_TESTS)
             test/test_kvflash_placement.cpp
             test/test_kvflash_pool_sizing.cpp
             test/test_kvflash_qk.cpp
+            test/test_moe_expert_owner_placement.cpp
+            test/test_moe_stream_owner_partition.cpp
             test/test_qwen35moe_routing_stats.cpp
             test/test_qwen35moe_expert_placement.cpp
             test/test_qwen35moe_swap_manager.cpp

server/deps/llama.cpp/ggml/src/ggml-cuda/ggml-cuda.cu

@@ -5382,10 +5382,14 @@ static bool ggml_backend_cuda_get_available_uma_memory(long * available_memory_k
 }
 #endif // defined(__linux__)
 
+static void ggml_backend_cuda_device_get_native_memory(ggml_backend_dev_t dev, size_t * free, size_t * total) {
+    ggml_backend_cuda_device_context * ctx = (ggml_backend_cuda_device_context *)dev->context;
+    ggml_backend_cuda_get_device_memory(ctx->device, free, total);
+}
+
 static void ggml_backend_cuda_device_get_memory(ggml_backend_dev_t dev, size_t * free, size_t * total) {
     ggml_backend_cuda_device_context * ctx = (ggml_backend_cuda_device_context *)dev->context;
-    ggml_cuda_set_device(ctx->device);
-    CUDA_CHECK(cudaMemGetInfo(free, total));
+    ggml_backend_cuda_device_get_native_memory(dev, free, total);
 
 // ref: https://github.com/ggml-org/llama.cpp/pull/17368
 #if defined(__linux__)
@@ -6123,6 +6127,9 @@ static void * ggml_backend_cuda_reg_get_proc_address(ggml_backend_reg_t reg, con
     if (strcmp(name, "ggml_backend_get_features") == 0) {
         return (void *)ggml_backend_cuda_get_features;
     }
+    if (strcmp(name, "ggml_backend_dev_get_native_memory") == 0) {
+        return (void *)ggml_backend_cuda_device_get_native_memory;
+    }
     return nullptr;
 }
 

server/docs/DS4.md

@@ -225,6 +225,18 @@ If DeepSeek4 is started without an explicit target layer split, `DeepSeek4LayerS
 
 The runtime logs the chosen split with a `[deepseek4-split] auto-split:` banner.
 
+### NVMe cold-capacity tier
+
+When the cold expert stack cannot fit on its compute device, the inference
+engine turns safe remaining memory into an adaptive warm-expert cache and
+streams only exact routed misses from NVMe. This supports both R9700+Strix
+expert parallelism and a single Strix Halo. `--moe-storage auto` selects
+streaming when capacity requires it; `ssd` forces at least one cold expert per
+layer for qualification and `resident` prohibits SSD execution. On a
+full Lucebox the R9700 continues to own dense layers and hot experts. See
+[`MOE_NVME_STREAMING.md`](MOE_NVME_STREAMING.md) for the data path, tuning,
+and benchmark methodology.
+
 ## Environment Variables
 
 | Variable | Purpose |
@@ -245,6 +257,9 @@ The runtime logs the chosen split with a `[deepseek4-split] auto-split:` banner.
 | `DFLASH_DS4_COMP_PAD_STRIDE` | Exact compressed-KV padding bucket; wider buckets trade small masked work for fewer verifier graph captures. |
 | `DFLASH_DS4_DISABLE_GROUPED_OUTPUT_PROJECTION` | Diagnostic fallback for runtimes that cannot preserve grouped projection metadata across a scheduler copy. |
 | `DFLASH_CUDA_BACKEND_PATH` / `DFLASH_HIP_BACKEND_PATH` | Optional explicit peer backend module path. |
+| `DFLASH_MOE_STORAGE` | Environment equivalent of `--moe-storage auto|resident|ssd`; CLI takes precedence. |
+| `DFLASH_MOE_NVME_COLD_TIER` | Deprecated compatibility alias (`auto`, `on`, `off`). |
+| `DFLASH_MOE_NVME_DEVICE_CACHE_MB` | Optional explicit adaptive device expert-cache budget; auto mode otherwise uses safe free memory. |
 | `DFLASH_EXPERT_BUDGET_MB` | Main-GPU memory budget for hot experts. |
 | `DFLASH_DS4_HOTNESS_CSV` | Optional per-layer routing profile for hot placement. |
 | `GGML_BATCH_PEER_COPIES` | Batch peer-runtime copies and unlike-runtime pinned-host staging with one source wait per split. The old `GGML_CUDA_BATCH_PEER_COPIES` spelling remains an alias. |

server/docs/ENVIRONMENT.md

@@ -40,6 +40,15 @@ consolidation of this list into CLI flags is tracked as follow-up work.
 | `DFLASH_CUDA_BACKEND_PATH` / `DFLASH_HIP_BACKEND_PATH` | auto-discovered beside the executable | Explicit peer module file path for a mixed CUDA+HIP build. |
 | `GGML_BATCH_PEER_COPIES` | unset | BURN-IN: batch peer-runtime copies and unlike-runtime host staging with one source wait per split. `GGML_CUDA_BATCH_PEER_COPIES` remains a compatibility alias. |
 | `GGML_SCHED_PROFILE` / `GGML_SCHED_PROFILE_MIN_SPLITS` | unset / 1 | DEBUG: report scheduler splits, copy volume, submission time, and source/destination synchronization time. |
+| `DFLASH_MOE_TP_GPU` | primary device | BURN-IN: optional secondary routed-expert GPU; Kimi executes exact route partitions concurrently when it differs from the primary. |
+| `DFLASH_MOE_PLACEMENT` | unset | BURN-IN: offline placement JSON; listed experts belong to the primary owner. |
+| `DFLASH_MOE_PRIMARY_SHARE_PER_MILLE` | 500 | BURN-IN: deterministic primary route share when no explicit placement is supplied. |
+| `DFLASH_MOE_DUAL_STREAM_TRACE` | unset | DEBUG: per-layer dual-owner route counts and branch/wall timings. |
+| `DFLASH_MOE_STORAGE` | auto | Routed-MoE storage policy (`auto`, `resident`, `ssd`); prefer `--moe-storage`, which takes precedence. |
+| `DFLASH_MOE_NVME_COLD_TIER` | unset | DEPRECATED: DeepSeek compatibility alias (`auto`, `on`, `off`). |
+| `DFLASH_MOE_NVME_*` | tuned defaults | BURN-IN: bounded MoE SSD scheduler/backend controls; see `MOE_NVME_STREAMING.md`. |
+| `DFLASH_MOE_EXPERT_PACKAGE` / `DFLASH_MOE_EXPERT_PACKAGE_BUILD` | unset | BURN-IN: use or explicitly build a validated, byte-exact expert-major SSD package. |
+| `DFLASH_MOE_ROUTE_STATS_OUT` / `DFLASH_MOE_HOTNESS_CSV` | unset | BURN-IN: capture native route counts, then profile-warm and pin valuable streamed experts. |
 | `DFLASH_MOE_PREFILL_PERSISTENT_OWNER_ALLOC` | 1 for qualified long heterogeneous prefill | KILL SWITCH: =0 restores per-layer route/owner scratch allocation. |
 | `DFLASH_MOE_TP_*` / `DFLASH_MOE_HYBRID_PREFILL_EAGER` | unset | BURN-IN: model-neutral names for common heterogeneous-MoE scheduling and kernel policy. Existing `DFLASH_DS4_*` names remain compatibility aliases. |
 | `DFLASH_MMID_TELEMETRY` | unset | DEBUG: report MUL_MAT_ID dispatch, MMVQ variant, and per-node graph compatibility. |
@@ -181,6 +190,7 @@ consolidation of this list into CLI flags is tracked as follow-up work.
 - `DFLASH_MODEL_CARDS_DIR` - model_card.cpp
 - `DFLASH_MOE_COLD_BACKEND` - deepseek4_loader.cpp
 - `DFLASH_MOE_COMPACT_MATERIALIZED` - moe_hybrid_ffn_eval.cpp
+- `DFLASH_MOE_DUAL_STREAM_TRACE` - kimi_k3_graph.cpp
 - `DFLASH_MOE_DUPLICATE_HOT_ON_COLD` - moe_hybrid_storage.cpp
 - `DFLASH_MOE_EXPERT_COMPUTE_DAEMON_TOKEN_LOOP` - moe_expert_compute_ipc.cpp
 - `DFLASH_MOE_EXPERT_COMPUTE_IPC_BATCH_CAPACITY` - moe_expert_compute_ipc.cpp
@@ -191,16 +201,22 @@ consolidation of this list into CLI flags is tracked as follow-up work.
 - `DFLASH_MOE_EXPERT_COMPUTE_IPC_SHARED_BYTES` - moe_expert_compute_ipc.cpp
 - `DFLASH_MOE_EXPERT_COMPUTE_IPC_TRANSPORT` - moe_expert_compute_ipc.cpp
 - `DFLASH_MOE_EXPERT_COMPUTE_THREADS` - moe_expert_compute_cpu.cpp
+- `DFLASH_MOE_EXPERT_PACKAGE` - kimi_k3_backend.cpp
+- `DFLASH_MOE_EXPERT_PACKAGE_BUILD` - kimi_k3_backend.cpp
 - `DFLASH_MOE_EXPERT_MAJOR_GPU_REDUCE` - moe_hybrid_ffn_eval.cpp
 - `DFLASH_MOE_EXPERT_MAJOR_PREFILL` - moe_hybrid_ffn_eval.cpp
 - `DFLASH_MOE_FIXED_SLOT_GRAPHS` - moe_hybrid_ffn_eval.cpp
 - `DFLASH_MOE_FIXED_SLOT_MAX` - moe_hybrid_ffn_eval.cpp
 - `DFLASH_MOE_FULL_COLD_PARALLEL` - moe_hybrid_ffn_eval.cpp
 - `DFLASH_MOE_FUSED_COMBINE` - moe_hybrid_ffn_eval.cpp
+- `DFLASH_MOE_HOTNESS_CSV` - kimi_k3_backend.cpp
+- `DFLASH_MOE_PLACEMENT` - kimi_k3_backend.cpp
 - `DFLASH_MOE_PREFILL_DEVICE_INPUT` - deepseek4_graph.cpp
 - `DFLASH_MOE_PREFILL_HOT_SUB_BATCH` - moe_hybrid_ffn_eval.cpp
 - `DFLASH_MOE_PREFILL_MASKED_COLD` - moe_hybrid_ffn_eval.cpp
 - `DFLASH_MOE_PREFILL_PERSISTENT_OWNER_ALLOC` - deepseek4_graph.cpp
+- `DFLASH_MOE_PRIMARY_SHARE_PER_MILLE` - moe_hybrid_stream.cpp
+- `DFLASH_MOE_ROUTE_STATS_OUT` - kimi_k3_backend.cpp
 - `DFLASH_MOE_TP_BACKEND` - deepseek4_backend.cpp
 - `DFLASH_NO_MASK` - laguna_backend.cpp
 - `DFLASH_NO_MOE_ROUTER_FUSE` - qwen35moe_ffn.cpp