fix: revert deep-copy, restore stable rebuild-every-token path (#huanglawsded)

- Deep-copy via new ggml_tensor(*src) caused SIGFPE in CPU compute
  (src[] pointers stale, nb values possibly corrupt for view tensors)
- Restored unified path: model.build_graph() every token + galloc fast-path
- Removed deep_copy_phase2_graph, persistent_gf, persistent_tensors
- Cleaned stray graph_compute(gf2) line left from previous edit
- phase2_cache.valid gate used for n_reused tracking on Token 2+

Author: Alex7MV

src/llama-context.cpp

@@ -1817,121 +1817,75 @@ llm_graph_result * llama_context::process_ubatch(const llama_ubatch & ubatch, ll
                     const bool do_cuda = (ubatch.n_tokens == 1);
                     ggml_cgraph * phase2_gf;
 
-                    if (do_cuda && phase2_cache.valid) {
-                        // REPLAY (Token 2+) — use persistent copy, skip build+cascade
-                        res->reset();
-                        ggml_backend_sched_reset(sched_phase2.get());
-                        phase2_gf = phase2_cache.persistent_gf;
-                        for (int i = 0; i < ggml_graph_n_nodes(phase2_gf); i++) {
-                            ggml_tensor * t = ggml_graph_node(phase2_gf, i);
-                            auto [tid, il] = moe::match_hijack_name(h2_hijack, t->name);
-                            if (tid >= 0)
-                                ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, gpu);
-                        }
-                        for (int i = 0; i < ggml_graph_n_leafs(phase2_gf); i++) {
-                            ggml_tensor * t = ggml_graph_leaf(phase2_gf, i);
-                            auto [tid, il] = moe::match_hijack_name(h2_hijack, t->name);
-                            if (tid >= 0)
-                                ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, gpu);
-                        }
-                        moe::cascade_force_moe_consumers(h2_hijack, phase2_gf, sched_phase2.get(), gpu);
-                        if (backend_cpu) {
-                            auto force = [&](ggml_tensor * t) {
-                                if (t) ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, backend_cpu);
-                            };
-                            for (auto & inp : res->inputs) {
-                                auto * base = inp.get();
-                                if (auto * akv = dynamic_cast<llm_graph_input_attn_kv *>(base)) {
-                                    force(akv->self_k_idxs); force(akv->self_v_idxs); force(akv->self_kq_mask);
-                                } else if (auto * ak = dynamic_cast<llm_graph_input_attn_k *>(base)) {
-                                    force(ak->self_k_idxs); force(ak->self_kq_mask);
-                                } else if (auto * dsa = dynamic_cast<llm_graph_input_attn_k_dsa *>(base)) {
-                                    force(dsa->self_k_idxs_mla); force(dsa->self_k_idxs_lid);
-                                    force(dsa->self_kq_mask_mla); force(dsa->self_kq_mask_lid);
-                                } else if (auto * iswa = dynamic_cast<llm_graph_input_attn_kv_iswa *>(base)) {
-                                    force(iswa->self_k_idxs); force(iswa->self_v_idxs);
-                                    force(iswa->self_k_idxs_swa); force(iswa->self_v_idxs_swa);
-                                    force(iswa->self_kq_mask); force(iswa->self_kq_mask_swa);
-                                } else if (auto * hyb = dynamic_cast<llm_graph_input_mem_hybrid *>(base)) {
-                                    force(hyb->inp_attn->self_k_idxs); force(hyb->inp_attn->self_v_idxs);
-                                    force(hyb->inp_attn->self_kq_mask);
-                                } else if (auto * hybk = dynamic_cast<llm_graph_input_mem_hybrid_k *>(base)) {
-                                    force(hybk->inp_attn->self_k_idxs); force(hybk->inp_attn->self_kq_mask);
-                                } else if (auto * hybiswa = dynamic_cast<llm_graph_input_mem_hybrid_iswa *>(base)) {
-                                    force(hybiswa->inp_attn->self_k_idxs); force(hybiswa->inp_attn->self_v_idxs);
-                                    force(hybiswa->inp_attn->self_k_idxs_swa); force(hybiswa->inp_attn->self_v_idxs_swa);
-                                    force(hybiswa->inp_attn->self_kq_mask); force(hybiswa->inp_attn->self_kq_mask_swa);
-                                } else if (auto * oid = dynamic_cast<llm_graph_input_out_ids *>(base)) {
-                                    force(oid->out_ids);
-                                }
-                            }
-                        }
-                        n_reused++;
-                    } else {
-                        // BUILD (Token 1) — build, cascade, deep-copy
-                        if (!sched_phase2) {
-                            const size_t phase2_n = std::max((size_t)graph_max_nodes(ubatch.n_tokens), (size_t)10000);
-                            sched_phase2.reset(ggml_backend_sched_new(backend_ptrs.data(), backend_buft.data(), backend_ptrs.size(), phase2_n, false, cparams.op_offload));
-                        }
-                        res->reset();
-                        ggml_backend_sched_reset(sched_phase2.get());
-                        moe_weight_cache.build_layer_only = -1;
-                        moe_weight_cache.build_phase = 2;
-                        phase2_gf = model.build_graph(gparams, nullptr, nullptr, &moe_weight_cache);
-                        if (!phase2_gf) { ret = GGML_STATUS_FAILED; return nullptr; }
-                        ggml_backend_sched_reset(sched_phase2.get());
-                        for (int i = 0; i < ggml_graph_n_nodes(phase2_gf); i++) {
-                            ggml_tensor * t = ggml_graph_node(phase2_gf, i);
-                            auto [tid, il] = moe::match_hijack_name(h2_hijack, t->name);
-                            if (tid >= 0)
-                                ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, gpu);
-                        }
-                        for (int i = 0; i < ggml_graph_n_leafs(phase2_gf); i++) {
-                            ggml_tensor * t = ggml_graph_leaf(phase2_gf, i);
-                            auto [tid, il] = moe::match_hijack_name(h2_hijack, t->name);
-                            if (tid >= 0)
-                                ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, gpu);
-                        }
-                        moe::cascade_force_moe_consumers(h2_hijack, phase2_gf, sched_phase2.get(), gpu);
-                        if (backend_cpu) {
-                            auto force = [&](ggml_tensor * t) {
-                                if (t) ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, backend_cpu);
-                            };
-                            for (auto & inp : res->inputs) {
-                                auto * base = inp.get();
-                                if (auto * akv = dynamic_cast<llm_graph_input_attn_kv *>(base)) {
-                                    force(akv->self_k_idxs); force(akv->self_v_idxs); force(akv->self_kq_mask);
-                                } else if (auto * ak = dynamic_cast<llm_graph_input_attn_k *>(base)) {
-                                    force(ak->self_k_idxs); force(ak->self_kq_mask);
-                                } else if (auto * dsa = dynamic_cast<llm_graph_input_attn_k_dsa *>(base)) {
-                                    force(dsa->self_k_idxs_mla); force(dsa->self_k_idxs_lid);
-                                    force(dsa->self_kq_mask_mla); force(dsa->self_kq_mask_lid);
-                                } else if (auto * iswa = dynamic_cast<llm_graph_input_attn_kv_iswa *>(base)) {
-                                    force(iswa->self_k_idxs); force(iswa->self_v_idxs);
-                                    force(iswa->self_k_idxs_swa); force(iswa->self_v_idxs_swa);
-                                    force(iswa->self_kq_mask); force(iswa->self_kq_mask_swa);
-                                } else if (auto * hyb = dynamic_cast<llm_graph_input_mem_hybrid *>(base)) {
-                                    force(hyb->inp_attn->self_k_idxs); force(hyb->inp_attn->self_v_idxs);
-                                    force(hyb->inp_attn->self_kq_mask);
-                                } else if (auto * hybk = dynamic_cast<llm_graph_input_mem_hybrid_k *>(base)) {
-                                    force(hybk->inp_attn->self_k_idxs); force(hybk->inp_attn->self_kq_mask);
-                                } else if (auto * hybiswa = dynamic_cast<llm_graph_input_mem_hybrid_iswa *>(base)) {
-                                    force(hybiswa->inp_attn->self_k_idxs); force(hybiswa->inp_attn->self_v_idxs);
-                                    force(hybiswa->inp_attn->self_k_idxs_swa); force(hybiswa->inp_attn->self_v_idxs_swa);
-                                    force(hybiswa->inp_attn->self_kq_mask); force(hybiswa->inp_attn->self_kq_mask_swa);
-                                } else if (auto * oid = dynamic_cast<llm_graph_input_out_ids *>(base)) {
-                                    force(oid->out_ids);
-                                }
+                    // Unified native compute via isolated sched_phase2.
+                    // galloc fast-path (backend_ids_changed=false) skips reserve_n on Token 2+.
+                    if (!sched_phase2) {
+                        const size_t phase2_n = std::max((size_t)graph_max_nodes(ubatch.n_tokens), (size_t)10000);
+                        sched_phase2.reset(ggml_backend_sched_new(backend_ptrs.data(), backend_buft.data(), backend_ptrs.size(), phase2_n, false, cparams.op_offload));
+                    }
+                    res->reset();
+                    ggml_backend_sched_reset(sched_phase2.get());
+                    moe_weight_cache.build_layer_only = -1;
+                    moe_weight_cache.build_phase = 2;
+                    phase2_gf = model.build_graph(gparams, nullptr, nullptr, &moe_weight_cache);
+                    if (!phase2_gf) { ret = GGML_STATUS_FAILED; return nullptr; }
+                    ggml_backend_sched_reset(sched_phase2.get());
+                    for (int i = 0; i < ggml_graph_n_nodes(phase2_gf); i++) {
+                        ggml_tensor * t = ggml_graph_node(phase2_gf, i);
+                        auto [tid, il] = moe::match_hijack_name(h2_hijack, t->name);
+                        if (tid >= 0)
+                            ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, gpu);
+                    }
+                    for (int i = 0; i < ggml_graph_n_leafs(phase2_gf); i++) {
+                        ggml_tensor * t = ggml_graph_leaf(phase2_gf, i);
+                        auto [tid, il] = moe::match_hijack_name(h2_hijack, t->name);
+                        if (tid >= 0)
+                            ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, gpu);
+                    }
+                    moe::cascade_force_moe_consumers(h2_hijack, phase2_gf, sched_phase2.get(), gpu);
+                    if (backend_cpu) {
+                        auto force = [&](ggml_tensor * t) {
+                            if (t) ggml_backend_sched_set_tensor_backend(sched_phase2.get(), t, backend_cpu);
+                        };
+                        for (auto & inp : res->inputs) {
+                            auto * base = inp.get();
+                            if (auto * akv = dynamic_cast<llm_graph_input_attn_kv *>(base)) {
+                                force(akv->self_k_idxs); force(akv->self_v_idxs); force(akv->self_kq_mask);
+                            } else if (auto * ak = dynamic_cast<llm_graph_input_attn_k *>(base)) {
+                                force(ak->self_k_idxs); force(ak->self_kq_mask);
+                            } else if (auto * dsa = dynamic_cast<llm_graph_input_attn_k_dsa *>(base)) {
+                                force(dsa->self_k_idxs_mla); force(dsa->self_k_idxs_lid);
+                                force(dsa->self_kq_mask_mla); force(dsa->self_kq_mask_lid);
+                            } else if (auto * iswa = dynamic_cast<llm_graph_input_attn_kv_iswa *>(base)) {
+                                force(iswa->self_k_idxs); force(iswa->self_v_idxs);
+                                force(iswa->self_k_idxs_swa); force(iswa->self_v_idxs_swa);
+                                force(iswa->self_kq_mask); force(iswa->self_kq_mask_swa);
+                            } else if (auto * hyb = dynamic_cast<llm_graph_input_mem_hybrid *>(base)) {
+                                force(hyb->inp_attn->self_k_idxs); force(hyb->inp_attn->self_v_idxs);
+                                force(hyb->inp_attn->self_kq_mask);
+                            } else if (auto * hybk = dynamic_cast<llm_graph_input_mem_hybrid_k *>(base)) {
+                                force(hybk->inp_attn->self_k_idxs); force(hybk->inp_attn->self_kq_mask);
+                            } else if (auto * hybiswa = dynamic_cast<llm_graph_input_mem_hybrid_iswa *>(base)) {
+                                force(hybiswa->inp_attn->self_k_idxs); force(hybiswa->inp_attn->self_v_idxs);
+                                force(hybiswa->inp_attn->self_k_idxs_swa); force(hybiswa->inp_attn->self_v_idxs_swa);
+                                force(hybiswa->inp_attn->self_kq_mask); force(hybiswa->inp_attn->self_kq_mask_swa);
+                            } else if (auto * oid = dynamic_cast<llm_graph_input_out_ids *>(base)) {
+                                force(oid->out_ids);
                             }
                         }
-                        moe::deep_copy_phase2_graph(phase2_cache, phase2_gf);
-                        if (!phase2_cache.persistent_gf) { ret = GGML_STATUS_FAILED; return nullptr; }
-                        h2_hijack.captured = true;
                     }
 
-                    // alloc_graph: Token 1 = full reserve+alloc; Token 2+ = galloc fast-path
+                    // alloc_graph: Token 1 = full reserve+alloc; Token 2+ = galloc fast-path (no reserve_n)
                     if (!ggml_backend_sched_alloc_graph(sched_phase2.get(), phase2_gf)) { ret = GGML_STATUS_ALLOC_FAILED; return nullptr; }
 
+                    // Track cache hit for server metrics
+                    if (do_cuda && phase2_cache.valid) {
+                        n_reused++;
+                    }
+                    if (!phase2_cache.valid) {
+                        phase2_cache.capture();
+                    }
+
                     ggml_backend_t be = ggml_backend_sched_get_backend(sched_phase2.get(), 0);
                     if (res->t_logits) ggml_backend_sched_set_tensor_backend(sched_phase2.get(), res->t_logits, be);
                     if (res->t_embd)   ggml_backend_sched_set_tensor_backend(sched_phase2.get(), res->t_embd,   be);
@@ -1948,19 +1902,6 @@ llm_graph_result * llama_context::process_ubatch(const llama_ubatch & ubatch, ll
 
                     if (res->t_logits)
                         moe_weight_cache.phase2_logits_data = res->t_logits->data;
-#else
-                    res->reset();
-                    ggml_backend_sched_reset(sched.get());
-                    moe_weight_cache.build_layer_only = -1;
-                    moe_weight_cache.build_phase = 2;
-                    ggml_cgraph * gf2 = model.build_graph(gparams, nullptr, nullptr, &moe_weight_cache);
-                    if (!gf2) { ret = GGML_STATUS_FAILED; return nullptr; }
-                    ggml_backend_sched_reset(sched.get());
-                    force_idxs_to_cpu();
-                    if (!ggml_backend_sched_alloc_graph(sched.get(), gf2)) { ret = GGML_STATUS_ALLOC_FAILED; return nullptr; }
-                    res->set_inputs(&ubatch);
-                    ggml_backend_sched_synchronize(sched.get());
-                    { auto s = graph_compute(gf2, ubatch.n_tokens > 1); if (s != GGML_STATUS_SUCCESS) { ret = s; return nullptr; } }
 #endif
 
                 // Toggle compact buffer (disabled — CUDA graph needs stable addresses)

src/moe-hijacker.cpp

@@ -4,12 +4,10 @@
 #include "moe-static-bunker.h"
 
 #include "ggml.h"
-#include "../ggml/src/ggml-impl.h"
 #include "ggml-backend.h"
 
 #include <cstdio>
 #include <cstring>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -187,76 +185,6 @@ void cascade_force_moe_consumers(
     }
 }
 
-// ---- Phase 2 Graph Deep-Copy ----
-
-void phase2_graph_cache::release() {
-    for (auto * t : persistent_tensors) delete t;
-    persistent_tensors.clear();
-    if (persistent_gf) { delete[] (char *)persistent_gf; persistent_gf = nullptr; }
-    valid = false;
-}
-
-void deep_copy_phase2_graph(
-    phase2_graph_cache & cache,
-    ggml_cgraph * src_gf)
-{
-    cache.release();
-
-    int n_nodes = ggml_graph_n_nodes(src_gf);
-    int n_leafs = ggml_graph_n_leafs(src_gf);
-    int total_t = n_nodes + n_leafs;
-
-    std::unordered_map<const ggml_tensor *, ggml_tensor *> map;
-
-    auto dup_tensor = [&](const ggml_tensor * src) -> ggml_tensor * {
-        auto * dst = new ggml_tensor(*src);
-        for (int s = 0; s < GGML_MAX_SRC; s++) dst->src[s] = src->src[s];
-        dst->view_src = src->view_src;
-        map[src] = dst;
-        cache.persistent_tensors.push_back(dst);
-        return dst;
-    };
-
-    for (int i = 0; i < n_leafs; i++) dup_tensor(ggml_graph_leaf(src_gf, i));
-    for (int i = 0; i < n_nodes; i++) dup_tensor(ggml_graph_node(src_gf, i));
-
-    for (auto * dst : cache.persistent_tensors) {
-        for (int s = 0; s < GGML_MAX_SRC; s++) {
-            if (dst->src[s]) {
-                auto it = map.find(dst->src[s]);
-                if (it != map.end()) dst->src[s] = it->second;
-            }
-        }
-        if (dst->view_src) {
-            auto it = map.find(dst->view_src);
-            if (it != map.end()) dst->view_src = it->second;
-        }
-    }
-
-    size_t graph_bytes = sizeof(ggml_cgraph) + (size_t)total_t * sizeof(ggml_tensor *) * 2;
-    char * buf = new char[graph_bytes]();
-    cache.persistent_gf = (ggml_cgraph *)buf;
-    cache.persistent_gf->size    = total_t;
-    cache.persistent_gf->n_nodes = 0;
-    cache.persistent_gf->n_leafs = 0;
-    cache.persistent_gf->nodes   = (ggml_tensor **)(buf + sizeof(ggml_cgraph));
-    cache.persistent_gf->leafs   = cache.persistent_gf->nodes + total_t;
-    cache.persistent_gf->order   = src_gf->order;
-    cache.persistent_gf->uid     = 0;
-
-    for (int i = 0; i < n_leafs; i++) {
-        auto it = map.find(ggml_graph_leaf(src_gf, i));
-        cache.persistent_gf->leafs[cache.persistent_gf->n_leafs++] = it->second;
-    }
-    for (int i = 0; i < n_nodes; i++) {
-        auto it = map.find(ggml_graph_node(src_gf, i));
-        cache.persistent_gf->nodes[cache.persistent_gf->n_nodes++] = it->second;
-    }
-
-    cache.valid = true;
-    fprintf(stderr, "deep_copy_phase2_graph: copied %d nodes + %d leafs\n", n_nodes, n_leafs);
-}
-
 } // namespace moe
 
 #endif // GGML_USE_CUDA

src/moe-hijacker.h

@@ -1,20 +1,17 @@
 #pragma once
 
-// Graph scanning, cascade forcing, and deep-copy caching for MoE Phase 2.
+// Graph scanning and cascade forcing for MoE Phase 2.
 // Operates on phase2_hijack structs via reference parameters.
 // All functions are in namespace moe.
 
 #ifdef GGML_USE_CUDA
 
 #include <utility>
-#include <unordered_map>
-#include <vector>
 
 #include "ggml-backend.h"
 
 struct phase2_hijack;
 struct ggml_cgraph;
-struct ggml_tensor;
 
 namespace moe {
 
@@ -36,17 +33,11 @@ void cascade_force_moe_consumers(
 
 struct phase2_graph_cache {
     bool valid = false;
-    ggml_cgraph * persistent_gf = nullptr;
-    std::vector<ggml_tensor *> persistent_tensors;
 
     void capture() { valid = true; }
-    void release();
+    void release() { valid = false; }
 };
 
-void deep_copy_phase2_graph(
-    phase2_graph_cache & cache,
-    ggml_cgraph * src_gf);
-
 } // namespace moe
 
 #endif // GGML_USE_CUDA