[lib][rr_graph] remove template id from graph builder and graph storage

amin1377 · amin1377 · commit 092a7cbb8d70 · 2025-12-12T10:45:23.000-08:00
diff --git a/libs/librrgraph/src/base/rr_graph_builder.cpp b/libs/librrgraph/src/base/rr_graph_builder.cpp
@@ -179,9 +179,8 @@ void RRGraphBuilder::reorder_nodes(e_rr_node_reorder_algorithm reorder_rr_graph_
 void RRGraphBuilder::create_edge_in_cache(RRNodeId src,
                                           RRNodeId dest,
                                           RRSwitchId edge_switch,
-                                          bool remapped,
-                                          std::optional<std::string> sw_template_id_) {
-    edges_to_build_.emplace_back(src, dest, size_t(edge_switch), remapped, sw_template_id_);
+                                          bool remapped) {
+    edges_to_build_.emplace_back(src, dest, size_t(edge_switch), remapped);
     is_edge_dirty_ = true; // Adding a new edge revokes the flag
     is_incoming_edge_dirty_ = true;
 }
diff --git a/libs/librrgraph/src/base/rr_graph_builder.h b/libs/librrgraph/src/base/rr_graph_builder.h
@@ -293,8 +293,7 @@ class RRGraphBuilder {
     void create_edge_in_cache(RRNodeId src,
                               RRNodeId dest,
                               RRSwitchId edge_switch,
-                              bool remapped,
-                              std::optional<std::string> sw_template_id_=std::nullopt);
+                              bool remapped);
 
     /** @brief Add a new edge to the cache of edges to be built 
      *  @note This will not add an edge to storage! You need to call build_edges() after all the edges are cached! */
@@ -340,9 +339,8 @@ class RRGraphBuilder {
     inline void emplace_back_edge(RRNodeId src,
                                   RRNodeId dest,
                                   short edge_switch,
-                                  bool remapped,
-                                  std::optional<std::string> sw_template_id=std::nullopt) {
-        node_storage_.emplace_back_edge(src, dest, edge_switch, remapped, sw_template_id);
+                                  bool remapped) {
+        node_storage_.emplace_back_edge(src, dest, edge_switch, remapped);
     }
     /** @brief Append 1 more RR node to the RR graph. */
     inline void emplace_back() {
diff --git a/libs/librrgraph/src/base/rr_graph_storage.cpp b/libs/librrgraph/src/base/rr_graph_storage.cpp
@@ -16,21 +16,18 @@ void t_rr_graph_storage::reserve_edges(size_t num_edges) {
     edge_dest_node_.reserve(num_edges);
     edge_switch_.reserve(num_edges);
     edge_remapped_.reserve(num_edges);
-    edge_sw_template_id_.reserve(num_edges);
 }
 
 void t_rr_graph_storage::emplace_back_edge(RRNodeId src,
                                            RRNodeId dest,
                                            short edge_switch,
-                                           bool remapped,
-                                           std::optional<std::string> sw_template_id) {
+                                           bool remapped) {
     // Cannot mutate edges once edges have been read!
     VTR_ASSERT(!edges_read_);
     edge_src_node_.emplace_back(src);
     edge_dest_node_.emplace_back(dest);
     edge_switch_.emplace_back(edge_switch);
     edge_remapped_.emplace_back(remapped);
-    edge_sw_template_id_.emplace_back(std::move(sw_template_id));
 }
 
 // Typical node to edge ratio.  This allows a preallocation guess for the edges
@@ -55,16 +52,14 @@ void t_rr_graph_storage::alloc_and_load_edges(const t_rr_edge_info_set* rr_edges
         edge_dest_node_.reserve(new_capacity);
         edge_switch_.reserve(new_capacity);
         edge_remapped_.reserve(new_capacity);
-        edge_sw_template_id_.reserve(new_capacity);
     }
 
     for (const t_rr_edge_info& new_edge : *rr_edges_to_create) {
         emplace_back_edge(
             new_edge.from_node,
             new_edge.to_node,
             new_edge.switch_type,
-            new_edge.remapped,
-            new_edge.sw_template_id);
+            new_edge.remapped);
     }
 }
 
@@ -95,7 +90,6 @@ void t_rr_graph_storage::remove_edges(std::vector<RREdgeId>& rr_edges_to_remove)
         edge_src_node_[erase_idx] = edge_src_node_[RREdgeId(edge_list_end)];
         edge_switch_[erase_idx] = edge_switch_[RREdgeId(edge_list_end)];
         edge_remapped_[erase_idx] = edge_remapped_[RREdgeId(edge_list_end)];
-        edge_sw_template_id_[erase_idx] = edge_sw_template_id_[RREdgeId(edge_list_end)];
 
         // At this point we have no copies of what was at erase_idx and two copies of
         // what was at the end of the list. If we make the list one element shorter,
@@ -110,7 +104,6 @@ void t_rr_graph_storage::remove_edges(std::vector<RREdgeId>& rr_edges_to_remove)
     edge_src_node_.erase(edge_src_node_.begin() + edge_list_end + 1, edge_src_node_.end());
     edge_switch_.erase(edge_switch_.begin() + edge_list_end + 1, edge_switch_.end());
     edge_remapped_.erase(edge_remapped_.begin() + edge_list_end + 1, edge_remapped_.end());
-    edge_sw_template_id_.erase(edge_sw_template_id_.begin() + edge_list_end + 1, edge_sw_template_id_.end());
 
     VTR_ASSERT(edge_dest_node_.size() == (starting_edge_count - rr_edges_to_remove.size()));
 
@@ -136,7 +129,6 @@ void t_rr_graph_storage::assign_first_edges() {
     VTR_ASSERT(edge_dest_node_.size() == num_edges);
     VTR_ASSERT(edge_switch_.size() == num_edges);
     VTR_ASSERT(edge_remapped_.size() == num_edges);
-    VTR_ASSERT(edge_sw_template_id_.size() == num_edges);
 
     while (true) {
         VTR_ASSERT(first_edge_id < num_edges);
@@ -819,7 +811,6 @@ t_rr_graph_view t_rr_graph_storage::view() const {
         vtr::make_const_array_view_id(edge_src_node_),
         vtr::make_const_array_view_id(edge_dest_node_),
         vtr::make_const_array_view_id(edge_switch_),
-        vtr::make_const_array_view_id(edge_sw_template_id_),
         virtual_clock_network_root_idx_,
         vtr::make_const_array_view_id(node_bend_start_),
         vtr::make_const_array_view_id(node_bend_end_));
@@ -858,7 +849,6 @@ void t_rr_graph_storage::reorder(const vtr::vector<RRNodeId, RRNodeId>& order,
         auto old_edge_dest_node = edge_dest_node_;
         auto old_edge_switch = edge_switch_;
         auto old_edge_remapped = edge_remapped_;
-        auto old_edge_sw_template_id = edge_sw_template_id_;
         RREdgeId cur_edge(0);
 
         // Reorder edges by source node
@@ -872,7 +862,6 @@ void t_rr_graph_storage::reorder(const vtr::vector<RRNodeId, RRNodeId>& order,
                 edge_dest_node_[cur_edge] = order[old_edge_dest_node[e]];
                 edge_switch_[cur_edge] = old_edge_switch[e];
                 edge_remapped_[cur_edge] = old_edge_remapped[e];
-                edge_sw_template_id_[cur_edge] = old_edge_sw_template_id[e];
                 cur_edge = RREdgeId(size_t(cur_edge) + 1);
             }
         }
diff --git a/libs/librrgraph/src/base/rr_graph_storage.h b/libs/librrgraph/src/base/rr_graph_storage.h
@@ -485,10 +485,6 @@ class t_rr_graph_storage {
         return edge_source_node(edge_id(id, iedge));
     }
 
-    const std::optional<std::string>& edge_sw_template_id(RREdgeId edge) const {
-        return edge_sw_template_id_[edge];
-    }
-
     /** 
      * @brief Get the switch used for the specified edge. 
      */
@@ -631,7 +627,6 @@ class t_rr_graph_storage {
         edge_dest_node_.clear();
         edge_switch_.clear();
         edge_remapped_.clear();
-        edge_sw_template_id_.clear();
         edges_read_ = false;
         partitioned_ = false;
         remapped_edges_ = false;
@@ -668,7 +663,6 @@ class t_rr_graph_storage {
         edge_dest_node_.shrink_to_fit();
         edge_switch_.shrink_to_fit();
         edge_remapped_.shrink_to_fit();
-        edge_sw_template_id_.shrink_to_fit();
     }
 
     /** @brief Append 1 more RR node to the RR graph.*/
@@ -836,8 +830,7 @@ class t_rr_graph_storage {
     void emplace_back_edge(RRNodeId src,
                            RRNodeId dest,
                            short edge_switch,
-                           bool remapped,
-                           std::optional<std::string> sw_template_id);
+                           bool remapped);
 
     /** @brief Adds a batch of edges.*/
     void alloc_and_load_edges(const t_rr_edge_info_set* rr_edges_to_create);
@@ -937,7 +930,6 @@ class t_rr_graph_storage {
         array_rearrange(edge_src_node_, RRNodeId::INVALID());
         array_rearrange(edge_dest_node_, RRNodeId::INVALID());
         array_rearrange(edge_switch_, LIBRRGRAPH_UNDEFINED_VAL);
-        array_rearrange(edge_sw_template_id_, std::nullopt);
         array_rearrange(edge_remapped_, false);
     }
 
@@ -1105,19 +1097,6 @@ class t_rr_graph_storage {
     */
     vtr::vector<RREdgeId, bool> edge_remapped_;
 
-    /** @brief
-     * This vector stores the template ID corresponding to each edge.
-     * It is primarily used for the tileable RR Graph. In a tileable RR Graph,
-     * we have a limited set of unique switch block patterns that are
-     * instantiated across the FPGA array. Each edge in a pattern has an ID.
-     * This data structure stores the ID of the pattern edge associated with
-     * each RR edge (i.e., the instantiated edge).
-     *
-     * This information can be used for various analyses, such as identifying
-     * which edges within each pattern are used most or least frequently.
-    */
-    vtr::vector<RREdgeId, std::optional<std::string>> edge_sw_template_id_;
-
     /** @brief
      * The following data structures are only used for tileable routing resource graph.
      * The tileable flag is set to true by tileable routing resource graph builder.
@@ -1182,7 +1161,6 @@ class t_rr_graph_view {
         const vtr::array_view_id<RREdgeId, const RRNodeId> edge_src_node,
         const vtr::array_view_id<RREdgeId, const RRNodeId> edge_dest_node,
         const vtr::array_view_id<RREdgeId, const short> edge_switch,
-        const vtr::array_view_id<RREdgeId, const std::optional<std::string>> edge_sw_template_id,
         const std::unordered_map<std::string, RRNodeId>& virtual_clock_network_root_idx,
         const vtr::array_view_id<RRNodeId, const int16_t> node_bend_start,
         const vtr::array_view_id<RRNodeId, const int16_t> node_bend_end)
@@ -1195,7 +1173,6 @@ class t_rr_graph_view {
         , edge_src_node_(edge_src_node)
         , edge_dest_node_(edge_dest_node)
         , edge_switch_(edge_switch)
-        , edge_sw_template_id_(edge_sw_template_id)
         , virtual_clock_network_root_idx_(virtual_clock_network_root_idx)
         , node_bend_start_(node_bend_start)
         , node_bend_end_(node_bend_end) {}
@@ -1384,10 +1361,6 @@ class t_rr_graph_view {
         return edge_switch_[edge];
     }
 
-    std::optional<std::string> edge_sw_template_id(RREdgeId edge) const {
-        return edge_sw_template_id_[edge];
-    }
-
   private:
     RREdgeId first_edge(RRNodeId id) const {
         return node_first_edge_[id];
@@ -1406,7 +1379,6 @@ class t_rr_graph_view {
     vtr::array_view_id<RREdgeId, const RRNodeId> edge_src_node_;
     vtr::array_view_id<RREdgeId, const RRNodeId> edge_dest_node_;
     vtr::array_view_id<RREdgeId, const short> edge_switch_;
-    vtr::array_view_id<RREdgeId, const std::optional<std::string>> edge_sw_template_id_;
     const std::unordered_map<std::string, RRNodeId>& virtual_clock_network_root_idx_;
 
     vtr::array_view_id<RRNodeId, const int16_t> node_bend_start_;
