Automated Code Change

PiperOrigin-RevId: 910799332

Author: XLS Team

xls/ir/proc_elaboration.cc

@@ -509,7 +509,7 @@ absl::StatusOr<ProcInstantiationPath> ProcElaboration::CreatePath(
 absl::StatusOr<std::pair<ProcElaboration::ChannelGraph,
                          std::vector<ProcElaboration::ChannelEdge>>>
 ProcElaboration::BuildChannelGraph() const {
-  ProcElaboration::ChannelGraph graph(
+  ProcElaboration::ChannelGraph::Builder builder(
       /*num_nodes=*/proc_instance_ptrs_.size() + 1,
       /*arc_capacity=*/channel_instance_ptrs_.size());
   struct MissingSide {
@@ -523,7 +523,7 @@ ProcElaboration::BuildChannelGraph() const {
   std::vector<ProcElaboration::ChannelEdge> refs;
   refs.reserve(channel_instance_ptrs_.size());
   for (ProcInstance* p : proc_instance_ptrs_) {
-    graph.AddNode(id);
+    builder.AddNode(id);
     for (Node* n : p->proc()->nodes()) {
       if (n->Is<Send>()) {
         XLS_ASSIGN_OR_RETURN(SendChannelRef ref,
@@ -545,7 +545,8 @@ ProcElaboration::BuildChannelGraph() const {
             // to support all cases.
             continue;
           }
-          ProcElaboration::ChannelId nxt = graph.AddArc(id, other_side[c]->id);
+          ProcElaboration::ChannelId nxt =
+              builder.AddArc(id, other_side[c]->id);
           XLS_RET_CHECK_EQ(nxt, refs.size());
           refs.push_back(
               {.send = ref,
@@ -574,7 +575,8 @@ ProcElaboration::BuildChannelGraph() const {
             // to support all cases.
             continue;
           }
-          ProcElaboration::ChannelId nxt = graph.AddArc(other_side[c]->id, id);
+          ProcElaboration::ChannelId nxt =
+              builder.AddArc(other_side[c]->id, id);
           XLS_RET_CHECK_EQ(nxt, refs.size());
           refs.push_back({.send = std::get<SendChannelRef>(other_side[c]->ref),
                           .recv = ref});
@@ -587,26 +589,24 @@ ProcElaboration::BuildChannelGraph() const {
     id++;
   }
   // Add external channels.
-  graph.AddNode(proc_instance_ptrs_.size());
+  builder.AddNode(proc_instance_ptrs_.size());
   for (const auto& [chan, other] : other_side) {
     if (!other) {
       continue;
     }
     const MissingSide& side = *other;
     if (std::holds_alternative<SendChannelRef>(side.ref)) {
-      graph.AddArc(side.id, external_id);
+      builder.AddArc(side.id, external_id);
       refs.push_back({.send = std::get<SendChannelRef>(side.ref),
                       .recv = static_cast<Channel*>(nullptr)});
     } else {
-      graph.AddArc(external_id, side.id);
+      builder.AddArc(external_id, side.id);
       refs.push_back({.send = static_cast<Channel*>(nullptr),
                       .recv = std::get<ReceiveChannelRef>(side.ref)});
     }
   }
   // NB Build can renumber arcs so we need to renumber the channel info.
-  std::vector<ProcElaboration::ChannelId> permutation;
-  graph.Build(&permutation);
-  util::Permute(permutation, &refs);
+  auto graph = std::move(builder).BuildGraphAndPermute(refs);
   return std::pair<ProcElaboration::ChannelGraph,
                    std::vector<ProcElaboration::ChannelEdge>>(std::move(graph),
                                                               std::move(refs));

xls/passes/dataflow_graph_analysis.cc

@@ -72,8 +72,8 @@ DataflowGraphAnalysis::DataflowGraphAnalysis(std::vector<Node*> topo_sort_nodes,
     node_to_index_[nodes_[i]] = i;
   }
 
-  graph_ = std::make_unique<Graph>();
-  graph_->AddNode(kSourceIndex);
+  Graph::Builder builder;
+  builder.AddNode(kSourceIndex);
   absl::flat_hash_map<ArcIndex, int64_t> arc_capacities;
   absl::flat_hash_map<Node*, ArcIndex> internal_arcs;
   absl::flat_hash_map<Node*, ArcIndex> source_arcs;
@@ -83,8 +83,8 @@ DataflowGraphAnalysis::DataflowGraphAnalysis(std::vector<Node*> topo_sort_nodes,
 
     NodeIndex v_in = InIndex(i);
     NodeIndex v_out = OutIndex(i);
-    graph_->AddNode(v_in);
-    graph_->AddNode(v_out);
+    builder.AddNode(v_in);
+    builder.AddNode(v_out);
 
     int64_t bit_count = node->GetType()->GetFlatBitCount();
 
@@ -94,7 +94,7 @@ DataflowGraphAnalysis::DataflowGraphAnalysis(std::vector<Node*> topo_sort_nodes,
     } else if (IsDataOriginating(node)) {
       // These nodes originate (potentially) variable data; they are the points
       // of entry for unknown data.
-      source_arcs[node] = graph_->AddArc(kSourceIndex, v_in);
+      source_arcs[node] = builder.AddArc(kSourceIndex, v_in);
       arc_capacities[source_arcs[node]] = bit_count;
     } else if (query_engine != nullptr) {
       if (std::optional<SharedLeafTypeTree<TernaryVector>> ternary_value =
@@ -108,17 +108,17 @@ DataflowGraphAnalysis::DataflowGraphAnalysis(std::vector<Node*> topo_sort_nodes,
       }
     }
 
-    internal_arcs[node] = graph_->AddArc(v_in, v_out);
+    internal_arcs[node] = builder.AddArc(v_in, v_out);
     arc_capacities[internal_arcs[node]] = unknown_bits;
-    sink_arcs[node] = graph_->AddArc(v_in, kSinkIndex);
+    sink_arcs[node] = builder.AddArc(v_in, kSinkIndex);
     arc_capacities[sink_arcs[node]] = 0;
     for (Node* user : node->users()) {
-      arc_capacities[graph_->AddArc(v_out, InIndex(user))] = unknown_bits;
+      arc_capacities[builder.AddArc(v_out, InIndex(user))] = unknown_bits;
     }
   }
 
   std::vector<ArcIndex> arc_permutation;
-  graph_->Build(&arc_permutation);
+  graph_ = std::move(builder).Build(&arc_permutation);
   auto permuted = [&](ArcIndex arc) {
     return arc < arc_permutation.size() ? arc_permutation[arc] : arc;
   };

xls/passes/folding_graph.cc

@@ -39,42 +39,10 @@
 
 namespace xls {
 
-namespace {
-
-// This function permutes the order of the elements of the array
-// @array_to_permute following the permutations listed in @permutation.
-//
-// This function is similar to util::Permute. There are only two differences
-// between this function and util::Permute:
-// 1) This function uses std::move rather than relying on the copy constructor.
-//    This is important when using smart pointers.
-// 2) This function relies on "typeof" to find the type of the elements of the
-//    array to permute.
-template <class IntVector, class Array>
-void Permute(const IntVector& permutation, Array* array_to_permute) {
-  if (permutation.empty()) {
-    return;
-  }
-  std::vector<std::remove_reference_t<decltype((*array_to_permute)[0])>> temp(
-      permutation.size());
-  for (size_t i = 0; i < permutation.size(); ++i) {
-    temp[i] = std::move((*array_to_permute)[i]);
-  }
-  for (size_t i = 0; i < permutation.size(); ++i) {
-    (*array_to_permute)[static_cast<size_t>(permutation[i])] =
-        std::move(temp[i]);
-  }
-}
-
-}  // namespace
-
 FoldingGraph::FoldingGraph(
     FunctionBase* f,
     std::vector<std::unique_ptr<BinaryFoldingAction>> foldable_actions)
     : f_{f} {
-  // Allocate the graph
-  graph_ = std::make_unique<Graph>();
-
   // Ensure deterministic construction of FoldingGraph
   std::sort(foldable_actions.begin(), foldable_actions.end(),
             [](const std::unique_ptr<BinaryFoldingAction>& a,
@@ -85,16 +53,16 @@ FoldingGraph::FoldingGraph(
               return a->GetFrom()->id() < b->GetFrom()->id();
             });
 
+  Graph::Builder builder;
+
   // Add the nodes
-  AddNodes(foldable_actions);
+  AddNodes(foldable_actions, builder);
 
   // Add the edges
-  AddEdges(std::move(foldable_actions));
+  AddEdges(std::move(foldable_actions), builder);
 
   // Build the graph
-  std::vector<EdgeIndex> edge_permutations;
-  graph_->Build(&edge_permutations);
-  Permute(edge_permutations, &edges_);
+  graph_ = std::move(builder).BuildAndPermute(edges_);
 
   // Print the folding graph
   if (VLOG_IS_ON(2)) {
@@ -141,7 +109,8 @@ FoldingGraph::FoldingGraph(
 FunctionBase* FoldingGraph::function() const { return f_; }
 
 void FoldingGraph::AddNodes(
-    absl::Span<const std::unique_ptr<BinaryFoldingAction>> foldable_actions) {
+    absl::Span<const std::unique_ptr<BinaryFoldingAction>> foldable_actions,
+    Graph::Builder& builder) {
   // Add all nodes involved in folding actions into the internal
   // representation.
   absl::flat_hash_set<Node*> already_added;
@@ -168,20 +137,21 @@ void FoldingGraph::AddNodes(
 
   // Add the nodes to the graph
   for (size_t i = 0; i < nodes_.size(); ++i) {
-    graph_->AddNode(i);
+    builder.AddNode(i);
   }
 }
 
 void FoldingGraph::AddEdges(
-    std::vector<std::unique_ptr<BinaryFoldingAction>> foldable_actions) {
+    std::vector<std::unique_ptr<BinaryFoldingAction>> foldable_actions,
+    Graph::Builder& builder) {
   // Add all edges to the graph
   for (std::unique_ptr<BinaryFoldingAction>& f : foldable_actions) {
     // Add a new edge into the graph to represent the current folding action
     NodeIndex from_index = node_to_index_.at(f->GetFrom());
     NodeIndex to_index = node_to_index_.at(f->GetTo());
-    CHECK(graph_->IsNodeValid(from_index));
-    CHECK(graph_->IsNodeValid(to_index));
-    graph_->AddArc(from_index, to_index);
+    CHECK(0 <= from_index && from_index < builder.num_nodes());
+    CHECK(0 <= to_index && to_index < builder.num_nodes());
+    builder.AddArc(from_index, to_index);
 
     // Add the current folding action to our internal representation
     edges_.push_back(std::move(f));

xls/passes/folding_graph.h

@@ -229,9 +229,11 @@ class FoldingGraph {
   absl::flat_hash_set<absl::flat_hash_set<NodeIndex>> cliques_;
 
   void AddNodes(
-      absl::Span<const std::unique_ptr<BinaryFoldingAction>> foldable_actions);
+      absl::Span<const std::unique_ptr<BinaryFoldingAction>> foldable_actions,
+      Graph::Builder& builder);
   void AddEdges(
-      std::vector<std::unique_ptr<BinaryFoldingAction>> foldable_actions);
+      std::vector<std::unique_ptr<BinaryFoldingAction>> foldable_actions,
+      Graph::Builder& builder);
   void IdentifyCliques();
 };