ggml-cuda: drop dead concurrent-region reorder path

The branch scratch buffer made the node interleaving obsolete, so the concurrent
branches already run in their original graph order. The "restore original order"
pass in ggml_cuda_graph_evaluate_and_capture is therefore a no-op, and the
ggml_cuda_concurrent_event::original_order it consumed is now unused.

Remove the reorder pass and original_order, keeping only the is_valid() check
that clears the events when a region cannot be safely overlapped.

Co-Authored-By: Claude Opus 4 (1M context) <noreply@anthropic.com>

Author: roberteg16

ggml/src/ggml-cuda/common.cuh

@@ -1244,10 +1244,6 @@ struct ggml_cuda_concurrent_event {
     int                                          n_streams = 0;
     std::unordered_map<const ggml_tensor *, int> stream_mapping;
 
-    // Original order of nodes in this concurrent region (before interleaving)
-    // Used to restore grouping for fusion within streams
-    std::vector<const ggml_tensor *> original_order;
-
     const ggml_tensor * join_node;
 
     ggml_cuda_concurrent_event() = default;
@@ -1270,7 +1266,6 @@ struct ggml_cuda_concurrent_event {
     , fork_event(other.fork_event)
     , n_streams(other.n_streams)
     , stream_mapping(std::move(other.stream_mapping))
-    , original_order(std::move(other.original_order))
     , join_node(other.join_node) {
         other.fork_event = nullptr;
     }

ggml/src/ggml-cuda/ggml-cuda.cu

@@ -4287,58 +4287,7 @@ static void ggml_cuda_graph_evaluate_and_capture(ggml_backend_cuda_context * cud
                 }
             }
 
-            if (should_launch_concurrent_events) {
-                // Restore original node order within each concurrent region to enable fusion within streams
-
-                std::unordered_map<const ggml_tensor *, int> node_to_idx;
-                node_to_idx.reserve(cgraph->n_nodes);
-                for (int i = 0; i < cgraph->n_nodes; ++i) {
-                    node_to_idx[cgraph->nodes[i]] = i;
-                }
-
-                for (auto & [fork_node, event] : stream_ctx.concurrent_events) {
-                    // Find positions of all nodes from this event in the current graph
-                    std::vector<int> positions;
-                    positions.reserve(event.original_order.size());
-
-                    bool all_found = true;
-                    for (const ggml_tensor * orig_node : event.original_order) {
-                        auto it = node_to_idx.find(orig_node);
-                        if (it != node_to_idx.end()) {
-                            positions.push_back(it->second);
-                        } else {
-                            all_found = false;
-                            break;
-                        }
-                    }
-
-                    if (!all_found || positions.size() != event.original_order.size()) {
-                        continue;
-                    }
-
-                    // Sort positions to get contiguous range
-                    std::vector<int> sorted_positions = positions;
-                    std::sort(sorted_positions.begin(), sorted_positions.end());
-
-                    bool is_contiguous = true;
-                    for (size_t i = 1; i < sorted_positions.size(); ++i) {
-                        if (sorted_positions[i] != sorted_positions[i-1] + 1) {
-                            is_contiguous = false;
-                            break;
-                        }
-                    }
-
-                    if (!is_contiguous) {
-                        continue;
-                    }
-
-                    // Restore original order at the sorted positions
-                    int start_pos = sorted_positions[0];
-                    for (size_t i = 0; i < event.original_order.size(); ++i) {
-                        cgraph->nodes[start_pos + i] = const_cast<ggml_tensor *>(event.original_order[i]);
-                    }
-                }
-            } else {
+            if (!should_launch_concurrent_events) {
                 stream_ctx.concurrent_events.clear();
             }
 
@@ -4758,13 +4707,6 @@ static void ggml_backend_cuda_graph_optimize(ggml_backend_t backend, ggml_cgraph
                     continue;
                 }
 
-                // Save the original order of nodes in this region before interleaving
-                // This is used later to restore grouping for fusion within streams
-                concurrent_event.original_order.reserve(total_branch_nodes);
-                for (int i = fork_node_idx + 1; i < join_node_idx; ++i) {
-                    concurrent_event.original_order.push_back(cgraph->nodes[i]);
-                }
-
                 std::unordered_map<const ggml_tensor *, ggml_cuda_concurrent_event> & concurrent_events = cuda_ctx->stream_context().concurrent_events;
                 GGML_ASSERT(concurrent_events.find(root_node) == concurrent_events.end());
                 concurrent_events.emplace(root_node, std::move(concurrent_event));
@@ -4885,10 +4827,6 @@ static void ggml_backend_cuda_graph_optimize(ggml_backend_t backend, ggml_cgraph
         }
 
         const ggml_tensor * fork_node = cgraph->nodes[fork_idx];
-        concurrent_event.original_order.reserve(join_idx - fork_idx - 1);
-        for (int i = fork_idx + 1; i < join_idx; ++i) {
-            concurrent_event.original_order.push_back(cgraph->nodes[i]);
-        }
 
         std::unordered_map<const ggml_tensor *, ggml_cuda_concurrent_event> & concurrent_events = cuda_ctx->stream_context().concurrent_events;
         if (concurrent_events.find(fork_node) != concurrent_events.end()) {