[SYCL][Graph] Graph duplication optimizations in finalize() (#20547)

When invoking `auto g = graph.finalize()` on a graph with a moderate
amount of nodes, duplicating the nodes of the modifiable graph into the
executable graph takes a non-trivial amount of time. This PR introduces
a few changes to improve the performance of `duplicateNodes()`:

1. Replace the `std::dequeue` with a `std::vector` so that it can be
directly moved, omitting unnecessary O(n) allocations
2. Keep track of whether there are any subgraphs in the first pass of
the graph and skip the second pass of the graph if there are no
subgraphs
3. Add a `reserve()` for the vector of nodes and map that we are going
to create, since we know the total number of nodes.

> Note that 1. optimizes the fast path when the graph does not contain a
subgraph, but will likely make finalize slower for graphs that contain
subgraphs.

The changes for 2. make the diff seem much larger than it actually is,
but the majority of it is whitespace from moving the subgraph handling
into an if statement.

Author: adamfidel

sycl/source/detail/graph/graph_impl.cpp

@@ -1263,15 +1263,22 @@ exec_graph_impl::enqueue(sycl::detail::queue_impl &Queue,
 
 void exec_graph_impl::duplicateNodes() {
   // Map of original modifiable nodes (keys) to new duplicated nodes (values)
-  std::map<node_impl *, node_impl *> NodesMap;
-
+  std::unordered_map<node_impl *, node_impl *> NodesMap;
   nodes_range ModifiableNodes{MGraphImpl->MNodeStorage};
-  std::deque<std::shared_ptr<node_impl>> NewNodes;
+  std::vector<std::shared_ptr<node_impl>> NewNodes;
+
+  const size_t NodeCount = ModifiableNodes.size();
+  NodesMap.reserve(NodeCount);
+  NewNodes.reserve(NodeCount);
+
+  bool foundSubgraph = false;
 
   for (node_impl &OriginalNode : ModifiableNodes) {
     NewNodes.push_back(std::make_shared<node_impl>(OriginalNode));
     node_impl &NodeCopy = *NewNodes.back();
 
+    foundSubgraph |= (NodeCopy.MNodeType == node_type::subgraph);
+
     // Associate the ID of the original node with the node copy for later quick
     // access
     MIDCache.insert(std::make_pair(OriginalNode.MID, &NodeCopy));
@@ -1300,110 +1307,109 @@ void exec_graph_impl::duplicateNodes() {
 
   // Subgraph nodes need special handling, we extract all subgraph nodes and
   // merge them into the main node list
+  if (foundSubgraph) {
+    for (auto NewNodeIt = NewNodes.rbegin(); NewNodeIt != NewNodes.rend();
+         ++NewNodeIt) {
+      auto NewNode = *NewNodeIt;
+      if (NewNode->MNodeType != node_type::subgraph) {
+        continue;
+      }
+      nodes_range SubgraphNodes{NewNode->MSubGraphImpl->MNodeStorage};
+      std::deque<std::shared_ptr<node_impl>> NewSubgraphNodes{};
+
+      // Map of original subgraph nodes (keys) to new duplicated nodes (values)
+      std::map<node_impl *, node_impl *> SubgraphNodesMap;
+
+      // Copy subgraph nodes
+      for (node_impl &SubgraphNode : SubgraphNodes) {
+        NewSubgraphNodes.push_back(std::make_shared<node_impl>(SubgraphNode));
+        node_impl &NodeCopy = *NewSubgraphNodes.back();
+        // Associate the ID of the original subgraph node with all extracted
+        // node copies for future quick access.
+        MIDCache.insert(std::make_pair(SubgraphNode.MID, &NodeCopy));
+
+        SubgraphNodesMap.insert({&SubgraphNode, &NodeCopy});
+        NodeCopy.MSuccessors.clear();
+        NodeCopy.MPredecessors.clear();
+      }
 
-  for (auto NewNodeIt = NewNodes.rbegin(); NewNodeIt != NewNodes.rend();
-       ++NewNodeIt) {
-    auto NewNode = *NewNodeIt;
-    if (NewNode->MNodeType != node_type::subgraph) {
-      continue;
-    }
-    nodes_range SubgraphNodes{NewNode->MSubGraphImpl->MNodeStorage};
-    std::deque<std::shared_ptr<node_impl>> NewSubgraphNodes{};
-
-    // Map of original subgraph nodes (keys) to new duplicated nodes (values)
-    std::map<node_impl *, node_impl *> SubgraphNodesMap;
-
-    // Copy subgraph nodes
-    for (node_impl &SubgraphNode : SubgraphNodes) {
-      NewSubgraphNodes.push_back(std::make_shared<node_impl>(SubgraphNode));
-      node_impl &NodeCopy = *NewSubgraphNodes.back();
-      // Associate the ID of the original subgraph node with all extracted node
-      // copies for future quick access.
-      MIDCache.insert(std::make_pair(SubgraphNode.MID, &NodeCopy));
-
-      SubgraphNodesMap.insert({&SubgraphNode, &NodeCopy});
-      NodeCopy.MSuccessors.clear();
-      NodeCopy.MPredecessors.clear();
-    }
-
-    // Rebuild edges for new subgraph nodes
-    auto OrigIt = SubgraphNodes.begin(), OrigEnd = SubgraphNodes.end();
-    for (auto NewIt = NewSubgraphNodes.begin(); OrigIt != OrigEnd;
-         ++OrigIt, ++NewIt) {
-      node_impl &SubgraphNode = *OrigIt;
-      node_impl &NodeCopy = **NewIt;
+      // Rebuild edges for new subgraph nodes
+      auto OrigIt = SubgraphNodes.begin(), OrigEnd = SubgraphNodes.end();
+      for (auto NewIt = NewSubgraphNodes.begin(); OrigIt != OrigEnd;
+           ++OrigIt, ++NewIt) {
+        node_impl &SubgraphNode = *OrigIt;
+        node_impl &NodeCopy = **NewIt;
 
-      for (node_impl &NextNode : SubgraphNode.successors()) {
-        node_impl &Successor = *SubgraphNodesMap.at(&NextNode);
-        NodeCopy.registerSuccessor(Successor);
+        for (node_impl &NextNode : SubgraphNode.successors()) {
+          node_impl &Successor = *SubgraphNodesMap.at(&NextNode);
+          NodeCopy.registerSuccessor(Successor);
+        }
       }
-    }
 
-    // Collect input and output nodes for the subgraph
-    std::vector<node_impl *> Inputs;
-    std::vector<node_impl *> Outputs;
-    for (std::shared_ptr<node_impl> &NodeImpl : NewSubgraphNodes) {
-      if (NodeImpl->MPredecessors.size() == 0) {
-        Inputs.push_back(&*NodeImpl);
-      }
-      if (NodeImpl->MSuccessors.size() == 0) {
-        Outputs.push_back(&*NodeImpl);
+      // Collect input and output nodes for the subgraph
+      std::vector<node_impl *> Inputs;
+      std::vector<node_impl *> Outputs;
+      for (std::shared_ptr<node_impl> &NodeImpl : NewSubgraphNodes) {
+        if (NodeImpl->MPredecessors.size() == 0) {
+          Inputs.push_back(&*NodeImpl);
+        }
+        if (NodeImpl->MSuccessors.size() == 0) {
+          Outputs.push_back(&*NodeImpl);
+        }
       }
-    }
 
-    // Update the predecessors and successors of the nodes which reference the
-    // original subgraph node
+      // Update the predecessors and successors of the nodes which reference the
+      // original subgraph node
 
-    // Predecessors
-    for (node_impl &PredNode : NewNode->predecessors()) {
-      auto &Successors = PredNode.MSuccessors;
+      // Predecessors
+      for (node_impl &PredNode : NewNode->predecessors()) {
+        auto &Successors = PredNode.MSuccessors;
 
-      // Remove the subgraph node from this nodes successors
-      Successors.erase(
-          std::remove(Successors.begin(), Successors.end(), NewNode.get()),
-          Successors.end());
+        // Remove the subgraph node from this nodes successors
+        Successors.erase(
+            std::remove(Successors.begin(), Successors.end(), NewNode.get()),
+            Successors.end());
 
-      // Add all input nodes from the subgraph as successors for this node
-      // instead
-      for (node_impl *Input : Inputs) {
-        PredNode.registerSuccessor(*Input);
+        // Add all input nodes from the subgraph as successors for this node
+        // instead
+        for (node_impl *Input : Inputs) {
+          PredNode.registerSuccessor(*Input);
+        }
       }
-    }
 
-    // Successors
-    for (node_impl &SuccNode : NewNode->successors()) {
-      auto &Predecessors = SuccNode.MPredecessors;
+      // Successors
+      for (node_impl &SuccNode : NewNode->successors()) {
+        auto &Predecessors = SuccNode.MPredecessors;
 
-      // Remove the subgraph node from this nodes successors
-      Predecessors.erase(
-          std::remove(Predecessors.begin(), Predecessors.end(), NewNode.get()),
-          Predecessors.end());
+        // Remove the subgraph node from this nodes successors
+        Predecessors.erase(std::remove(Predecessors.begin(), Predecessors.end(),
+                                       NewNode.get()),
+                           Predecessors.end());
 
-      // Add all Output nodes from the subgraph as predecessors for this node
-      // instead
-      for (node_impl *Output : Outputs) {
-        Output->registerSuccessor(SuccNode);
+        // Add all Output nodes from the subgraph as predecessors for this node
+        // instead
+        for (node_impl *Output : Outputs) {
+          Output->registerSuccessor(SuccNode);
+        }
       }
-    }
 
-    // Remove single subgraph node and add all new individual subgraph nodes
-    // to the node storage in its place
-    auto OldPositionIt =
-        NewNodes.erase(std::find(NewNodes.begin(), NewNodes.end(), NewNode));
-    // Also set the iterator to the newly added nodes so we can continue
-    // iterating over all remaining nodes
-    auto InsertIt = NewNodes.insert(
-        OldPositionIt, std::make_move_iterator(NewSubgraphNodes.begin()),
-        std::make_move_iterator(NewSubgraphNodes.end()));
-    // Since the new reverse_iterator will be at i - 1 we need to advance it
-    // when constructing
-    NewNodeIt = std::make_reverse_iterator(std::next(InsertIt));
+      // Remove single subgraph node and add all new individual subgraph nodes
+      // to the node storage in its place
+      auto OldPositionIt =
+          NewNodes.erase(std::find(NewNodes.begin(), NewNodes.end(), NewNode));
+      // Also set the iterator to the newly added nodes so we can continue
+      // iterating over all remaining nodes
+      auto InsertIt = NewNodes.insert(
+          OldPositionIt, std::make_move_iterator(NewSubgraphNodes.begin()),
+          std::make_move_iterator(NewSubgraphNodes.end()));
+      // Since the new reverse_iterator will be at i - 1 we need to advance it
+      // when constructing
+      NewNodeIt = std::make_reverse_iterator(std::next(InsertIt));
+    }
   }
 
   // Store all the new nodes locally
-  MNodeStorage.insert(MNodeStorage.begin(),
-                      std::make_move_iterator(NewNodes.begin()),
-                      std::make_move_iterator(NewNodes.end()));
+  MNodeStorage = std::move(NewNodes);
 }
 
 void exec_graph_impl::update(std::shared_ptr<graph_impl> GraphImpl) {