feat(dflash): add direct DeepSeek4 pure-UMA runtime path

server/src/common/backend_factory.cpp

@@ -215,44 +215,33 @@ std::unique_ptr<ModelBackend> create_backend(const BackendArgs & args) {
         return backend;
 
     } else if (arch == "deepseek4") {
-        const PlacementBackend target_backend =
-            args.device.backend == PlacementBackend::Auto
-                ? compiled_placement_backend()
-                : args.device.backend;
-
-        // HIP single-device launches cannot rely on the CUDA/Halo auto-split
-        // path; use the single-backend loader, which can fall back to hybrid
-        // expert placement when a full monolithic load does not fit.
-        if (target_backend == PlacementBackend::Hip &&
-            !args.device.is_layer_split() &&
-            !args.remote_target_shard.enabled()) {
-            DeepSeek4BackendConfig cfg;
-            cfg.model_path = args.model_path;
-            cfg.device     = args.device;
-            cfg.stream_fd  = args.stream_fd;
-            cfg.max_ctx    = args.device.max_ctx;
-            cfg.chunk      = args.chunk;
-
-            auto backend = std::make_unique<DeepSeek4Backend>(cfg);
+        if (args.device.is_layer_split() || args.remote_target_shard.enabled()) {
+            DeepSeek4LayerSplitAdapterConfig cfg;
+            cfg.target_path         = args.model_path;
+            cfg.device              = args.device;
+            cfg.remote_target_shard = args.remote_target_shard;
+            cfg.chunk               = args.chunk;
+
+            auto adapter = std::make_unique<DeepSeek4LayerSplitAdapter>(cfg);
+            auto backend = std::make_unique<LayerSplitBackend>(std::move(adapter));
             if (!backend->init()) {
-                std::fprintf(stderr, "[backend_factory] DeepSeek4Backend init failed\n");
+                std::fprintf(stderr,
+                             "[backend_factory] LayerSplitBackend(deepseek4) init failed\n");
                 return nullptr;
             }
             return backend;
         }
 
-        // CUDA builds keep the layer-split backend so they can auto-split
-        // across CUDA and remote HIP target shards.
-        DeepSeek4LayerSplitAdapterConfig cfg;
-        cfg.target_path        = args.model_path;
-        cfg.device             = args.device;
-        cfg.remote_target_shard = args.remote_target_shard;
-        cfg.chunk              = args.chunk;
+        DeepSeek4BackendConfig dcfg;
+        dcfg.model_path = args.model_path;
+        dcfg.device     = args.device;
+        dcfg.stream_fd  = args.stream_fd;
+        dcfg.chunk      = args.chunk;
+        dcfg.max_ctx    = args.device.max_ctx;
 
-        auto adapter = std::make_unique<DeepSeek4LayerSplitAdapter>(cfg);
-        auto backend = std::make_unique<LayerSplitBackend>(std::move(adapter));
+        auto backend = std::make_unique<DeepSeek4Backend>(dcfg);
         if (!backend->init()) {
-            std::fprintf(stderr, "[backend_factory] LayerSplitBackend(deepseek4) init failed\n");
+            std::fprintf(stderr, "[backend_factory] DeepSeek4Backend init failed\n");
             return nullptr;
         }
         return backend;

server/src/deepseek4/deepseek4_backend.h

@@ -11,7 +11,7 @@
 #include "../common/moe_hybrid_placement.h"
 #include "../common/moe_hybrid_routing_stats.h"
 #include "../common/moe_hybrid_storage.h"
-#include "../common/moe_hybrid_stream.h"
+#include "../common/moe_expert_compute.h"
 #include "deepseek4_internal.h"
 
 #include "ggml.h"
@@ -60,6 +60,15 @@ class DeepSeek4Backend : public ModelBackend {
     void shutdown() override;
 
 private:
+    bool run_step_with_runtime_path(const float * embed,
+                                    int n_tokens,
+                                    int kv_start,
+                                    std::vector<float> & out_logits,
+                                    const int32_t * token_ids,
+                                    bool want_logits,
+                                    bool disable_cached_decode,
+                                    DeepSeek4StepTelemetry * telemetry);
+    void reset_request_state();
     DeepSeek4BackendConfig cfg_;
     ggml_backend_t         backend_      = nullptr;
     ggml_backend_t         snap_backend_ = nullptr;
@@ -74,6 +83,7 @@ class DeepSeek4Backend : public ModelBackend {
     // Snapshots
     static constexpr int PREFIX_SLOTS = 64;
     DeepSeek4Snapshot      snapshots_[PREFIX_SLOTS];
+    std::vector<float>     hc_state_;
     std::vector<float>     last_logits_;
 
     // Prefill prompt tokens in chunks, return absolute committed position.
@@ -92,14 +102,13 @@ class DeepSeek4Backend : public ModelBackend {
                                           int max_ctx,
                                           MoeHybridPlacement & out,
                                           std::string * err) const;
+    bool init_single_target_expert_runtime(std::string * err);
     void maybe_save_routing_stats();
 
     std::shared_ptr<MoeHybridStorage> moe_hybrid_;
     MoeHybridPlacement                moe_placement_;
-    MoeHybridStreamEngine             stream_engine_;
-    // Expert IPC removed — layer split replaces expert split.
-    // Kept for compilation compatibility; init_hybrid_model() is no longer called
-    // from the layer-split path.
+    MoeExpertComputeRuntime           expert_runtime_;
+    std::vector<uint64_t>             layer_expert_bytes_;
     std::shared_ptr<MoeHybridRoutingStats> routing_stats_;
     std::string                       routing_stats_out_path_;
 };