[vpr][crr] change crr_sw_temp_id to std::optional

amin1377 · amin1377 · commit 3c8afb74a5fb · 2025-12-10T15:48:11.000-08:00
diff --git a/libs/librrgraph/src/base/rr_graph_builder.cpp b/libs/librrgraph/src/base/rr_graph_builder.cpp
@@ -176,8 +176,12 @@ 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::string sw_template_id_) {
-    edges_to_build_.emplace_back(src, dest, size_t(edge_switch), remapped, std::move(sw_template_id_));
+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_);
     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
@@ -290,7 +290,11 @@ class RRGraphBuilder {
 
     /** @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. */
-    void create_edge_in_cache(RRNodeId src, RRNodeId dest, RRSwitchId edge_switch, bool remapped, std::string sw_template_id_="");
+    void create_edge_in_cache(RRNodeId src,
+                              RRNodeId dest,
+                              RRSwitchId edge_switch,
+                              bool remapped,
+                              std::optional<std::string> sw_template_id_=std::nullopt);
 
     /** @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! */
@@ -333,8 +337,12 @@ class RRGraphBuilder {
      * remap the arch switch id to rr switch id, the edge switch id of this edge shouldn't be changed. For example, when the intra-cluster graph
      * is built and the rr-graph related to global resources are read from a file, this parameter is true since the intra-cluster switches are
      * also listed in rr-graph file. So, we use that list to use the rr switch id instead of passing arch switch id for intra-cluster edges.*/
-    inline void emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch, bool remapped, std::string sw_template_id="") {
-        node_storage_.emplace_back_edge(src, dest, edge_switch, remapped, std::move(sw_template_id));
+    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);
     }
     /** @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
@@ -19,14 +19,18 @@ void t_rr_graph_storage::reserve_edges(size_t 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::string sw_template_id) {
+void t_rr_graph_storage::emplace_back_edge(RRNodeId src,
+                                           RRNodeId dest,
+                                           short edge_switch,
+                                           bool remapped,
+                                           std::optional<std::string> sw_template_id) {
     // 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(sw_template_id);
+    edge_sw_template_id_.emplace_back(std::move(sw_template_id));
 }
 
 // Typical node to edge ratio.  This allows a preallocation guess for the edges
diff --git a/libs/librrgraph/src/base/rr_graph_storage.h b/libs/librrgraph/src/base/rr_graph_storage.h
@@ -485,7 +485,7 @@ class t_rr_graph_storage {
         return edge_source_node(edge_id(id, iedge));
     }
 
-    std::string edge_sw_template_id(RREdgeId edge) const {
+    const std::optional<std::string>& edge_sw_template_id(RREdgeId edge) const {
         return edge_sw_template_id_[edge];
     }
 
@@ -833,7 +833,11 @@ class t_rr_graph_storage {
      * of the node. Also, the information about switches is fly-weighted and are accessible with IDs. Thus,
      * the number of rr switch types can be higher than the number of arch switch types.
      */
-    void emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch, bool remapped, std::string sw_template_id);
+    void emplace_back_edge(RRNodeId src,
+                           RRNodeId dest,
+                           short edge_switch,
+                           bool remapped,
+                           std::optional<std::string> sw_template_id);
 
     /** @brief Adds a batch of edges.*/
     void alloc_and_load_edges(const t_rr_edge_info_set* rr_edges_to_create);
@@ -933,7 +937,7 @@ 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_, "");
+        array_rearrange(edge_sw_template_id_, std::nullopt);
         array_rearrange(edge_remapped_, false);
     }
 
@@ -1112,7 +1116,7 @@ class t_rr_graph_storage {
      * 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::string> edge_sw_template_id_;
+    vtr::vector<RREdgeId, std::optional<std::string>> edge_sw_template_id_;
 
     /** @brief
      * The following data structures are only used for tileable routing resource graph.
@@ -1178,7 +1182,7 @@ 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::string> edge_sw_template_id,
+        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)
@@ -1380,7 +1384,7 @@ class t_rr_graph_view {
         return edge_switch_[edge];
     }
 
-    std::string edge_sw_template_id(RREdgeId edge) const {
+    std::optional<std::string> edge_sw_template_id(RREdgeId edge) const {
         return edge_sw_template_id_[edge];
     }
 
@@ -1402,7 +1406,7 @@ 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::string> edge_sw_template_id_;
+    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_;
diff --git a/libs/librrgraph/src/base/rr_graph_view.h b/libs/librrgraph/src/base/rr_graph_view.h
@@ -515,7 +515,7 @@ class RRGraphView {
         return node_storage_.edge_source_node(id, iedge);
     }
 
-    inline std::string edge_sw_template_id(RREdgeId edge) const {
+    inline const std::optional<std::string>& edge_sw_template_id(RREdgeId edge) const {
         return node_storage_.edge_sw_template_id(edge);
     }
 
diff --git a/vpr/src/base/stats.cpp b/vpr/src/base/stats.cpp
@@ -240,14 +240,14 @@ void write_sb_count_stats(const Netlist<>& net_list,
                 RRNodeId sink_node = rt_node.inode;
                 std::vector<RREdgeId> edges = rr_graph.find_edges(src_node, sink_node);
                 VTR_ASSERT(edges.size() == 1);
-                std::string sb_id = rr_graph.edge_sw_template_id(edges[0]);
-                if (sb_id.empty()) {
+                const std::optional<std::string>& sb_id = rr_graph.edge_sw_template_id(edges[0]);
+                if (!sb_id) {
                     continue;
                 }
-                if (sb_count.find(sb_id) == sb_count.end()) {
-                    sb_count[sb_id] = 0;
+                if (sb_count.find(*sb_id) == sb_count.end()) {
+                    sb_count[*sb_id] = 0;
                 }
-                sb_count[sb_id]++;
+                sb_count[*sb_id]++;
             }
         }
     }
diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp
@@ -70,6 +70,10 @@ void build_crr_gsb_edges(RRGraphBuilder& rr_graph_builder,
             rr_switch_id = find_or_create_crr_switch_id(delay_ps);
         }
         VTR_ASSERT(rr_switch_id != RRSwitchId::INVALID());
-        rr_graph_builder.create_edge_in_cache(connection.src_node(), connection.sink_node(), rr_switch_id, false, connection.sw_template_id());
+        rr_graph_builder.create_edge_in_cache(connection.src_node(),
+                                              connection.sink_node(),
+                                              rr_switch_id,
+                                              false,
+                                              std::make_optional(connection.sw_template_id()));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -176,8 +176,12 @@ void RRGraphBuilder::reorder_nodes(e_rr_node_reorder_algorithm reorder_rr_graph_`
`176`	`176`	`});`
`177`	`177`	`}`
`178`	`178`
`179`		`-void RRGraphBuilder::create_edge_in_cache(RRNodeId src, RRNodeId dest, RRSwitchId edge_switch, bool remapped, std::string sw_template_id_) {`
`180`		`- edges_to_build_.emplace_back(src, dest, size_t(edge_switch), remapped, std::move(sw_template_id_));`
	`179`	`+void RRGraphBuilder::create_edge_in_cache(RRNodeId src,`
	`180`	`+ RRNodeId dest,`
	`181`	`+ RRSwitchId edge_switch,`
	`182`	`+ bool remapped,`
	`183`	`+ std::optional<std::string> sw_template_id_) {`
	`184`	`+ edges_to_build_.emplace_back(src, dest, size_t(edge_switch), remapped, sw_template_id_);`
`181`	`185`	`is_edge_dirty_ = true; // Adding a new edge revokes the flag`
`182`	`186`	`is_incoming_edge_dirty_ = true;`
`183`	`187`	`}`
Original file line number	Diff line number	Diff line change
`@@ -515,7 +515,7 @@ class RRGraphView {`
`515`	`515`	`return node_storage_.edge_source_node(id, iedge);`
`516`	`516`	`}`
`517`	`517`
`518`		`- inline std::string edge_sw_template_id(RREdgeId edge) const {`
	`518`	`+ inline const std::optional<std::string>& edge_sw_template_id(RREdgeId edge) const {`
`519`	`519`	`return node_storage_.edge_sw_template_id(edge);`
`520`	`520`	`}`
`521`	`521`
Original file line number	Diff line number	Diff line change
`@@ -240,14 +240,14 @@ void write_sb_count_stats(const Netlist<>& net_list,`
`240`	`240`	`RRNodeId sink_node = rt_node.inode;`
`241`	`241`	`std::vector<RREdgeId> edges = rr_graph.find_edges(src_node, sink_node);`
`242`	`242`	`VTR_ASSERT(edges.size() == 1);`
`243`		`- std::string sb_id = rr_graph.edge_sw_template_id(edges[0]);`
`244`		`- if (sb_id.empty()) {`
	`243`	`+ const std::optional<std::string>& sb_id = rr_graph.edge_sw_template_id(edges[0]);`
	`244`	`+ if (!sb_id) {`
`245`	`245`	`continue;`
`246`	`246`	`}`
`247`		`- if (sb_count.find(sb_id) == sb_count.end()) {`
`248`		`- sb_count[sb_id] = 0;`
	`247`	`+ if (sb_count.find(*sb_id) == sb_count.end()) {`
	`248`	`+ sb_count[*sb_id] = 0;`
`249`	`249`	`}`
`250`		`- sb_count[sb_id]++;`
	`250`	`+ sb_count[*sb_id]++;`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,10 @@ void build_crr_gsb_edges(RRGraphBuilder& rr_graph_builder,`
`70`	`70`	`rr_switch_id = find_or_create_crr_switch_id(delay_ps);`
`71`	`71`	`}`
`72`	`72`	`VTR_ASSERT(rr_switch_id != RRSwitchId::INVALID());`
`73`		`- rr_graph_builder.create_edge_in_cache(connection.src_node(), connection.sink_node(), rr_switch_id, false, connection.sw_template_id());`
	`73`	`+ rr_graph_builder.create_edge_in_cache(connection.src_node(),`
	`74`	`+ connection.sink_node(),`
	`75`	`+ rr_switch_id,`
	`76`	`+ false,`
	`77`	`+ std::make_optional(connection.sw_template_id()));`
`74`	`78`	`}`
`75`	`79`	`}`