[crr] rename crr_id to sw_tamplate_id

Author: amin1377

libs/librrgraph/src/base/rr_edge.h

@@ -7,18 +7,18 @@
 #include "rr_graph_fwd.h"
 
 struct t_rr_edge_info {
-    t_rr_edge_info(RRNodeId from, RRNodeId to, short type, bool is_remapped, std::string crr_id_="") noexcept
+    t_rr_edge_info(RRNodeId from, RRNodeId to, short type, bool is_remapped, std::string sw_template_id_="") noexcept
         : from_node(from)
         , to_node(to)
         , switch_type(type)
         , remapped(is_remapped)
-        , crr_id(std::move(crr_id_)) {}
+        , sw_template_id(std::move(sw_template_id_)) {}
 
     RRNodeId from_node = RRNodeId::INVALID();
     RRNodeId to_node = RRNodeId::INVALID();
     short switch_type = LIBRRGRAPH_UNDEFINED_VAL;
     bool remapped = false;
-    std::string crr_id = "";
+    std::string sw_template_id = "";
 
     friend bool operator<(const t_rr_edge_info& lhs, const t_rr_edge_info& rhs) {
         VTR_ASSERT(lhs.remapped == rhs.remapped);

libs/librrgraph/src/base/rr_graph_builder.cpp

@@ -176,8 +176,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::string crr_id_) {
-    edges_to_build_.emplace_back(src, dest, size_t(edge_switch), remapped, std::move(crr_id_));
+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_));
     is_edge_dirty_ = true; // Adding a new edge revokes the flag
     is_incoming_edge_dirty_ = true;
 }

libs/librrgraph/src/base/rr_graph_builder.h

@@ -290,7 +290,7 @@ 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 crr_id_="");
+    void create_edge_in_cache(RRNodeId src, RRNodeId dest, RRSwitchId edge_switch, bool remapped, std::string sw_template_id_="");
 
     /** @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 +333,8 @@ 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 crr_id="") {
-        node_storage_.emplace_back_edge(src, dest, edge_switch, remapped, std::move(crr_id));
+    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));
     }
     /** @brief Append 1 more RR node to the RR graph. */
     inline void emplace_back() {

libs/librrgraph/src/base/rr_graph_storage.cpp

@@ -16,17 +16,17 @@ 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_crr_id_.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::string crr_id) {
+void t_rr_graph_storage::emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch, bool remapped, 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_crr_id_.emplace_back(crr_id);
+    edge_sw_template_id_.emplace_back(sw_template_id);
 }
 
 // Typical node to edge ratio.  This allows a preallocation guess for the edges
@@ -51,7 +51,7 @@ 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_crr_id_.reserve(new_capacity);
+        edge_sw_template_id_.reserve(new_capacity);
     }
 
     for (const t_rr_edge_info& new_edge : *rr_edges_to_create) {
@@ -60,7 +60,7 @@ void t_rr_graph_storage::alloc_and_load_edges(const t_rr_edge_info_set* rr_edges
             new_edge.to_node,
             new_edge.switch_type,
             new_edge.remapped,
-            new_edge.crr_id);
+            new_edge.sw_template_id);
     }
 }
 
@@ -91,7 +91,7 @@ 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_crr_id_[erase_idx] = edge_crr_id_[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,
@@ -106,7 +106,7 @@ 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_crr_id_.erase(edge_crr_id_.begin() + edge_list_end + 1, edge_crr_id_.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()));
 
@@ -132,7 +132,7 @@ 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_crr_id_.size() == num_edges);
+    VTR_ASSERT(edge_sw_template_id_.size() == num_edges);
 
     while (true) {
         VTR_ASSERT(first_edge_id < num_edges);
@@ -815,7 +815,7 @@ 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_crr_id_),
+        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_));
@@ -854,7 +854,7 @@ 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_crr_id = edge_crr_id_;
+        auto old_edge_sw_template_id = edge_sw_template_id_;
         RREdgeId cur_edge(0);
 
         // Reorder edges by source node
@@ -868,7 +868,7 @@ 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_crr_id_[cur_edge] = old_edge_crr_id[e];
+                edge_sw_template_id_[cur_edge] = old_edge_sw_template_id[e];
                 cur_edge = RREdgeId(size_t(cur_edge) + 1);
             }
         }

libs/librrgraph/src/base/rr_graph_storage.h

@@ -485,8 +485,8 @@ class t_rr_graph_storage {
         return edge_source_node(edge_id(id, iedge));
     }
 
-    std::string edge_crr_id(RREdgeId edge) const {
-        return edge_crr_id_[edge];
+    std::string edge_sw_template_id(RREdgeId edge) const {
+        return edge_sw_template_id_[edge];
     }
 
     /** 
@@ -631,7 +631,7 @@ class t_rr_graph_storage {
         edge_dest_node_.clear();
         edge_switch_.clear();
         edge_remapped_.clear();
-        edge_crr_id_.clear();
+        edge_sw_template_id_.clear();
         edges_read_ = false;
         partitioned_ = false;
         remapped_edges_ = false;
@@ -668,7 +668,7 @@ class t_rr_graph_storage {
         edge_dest_node_.shrink_to_fit();
         edge_switch_.shrink_to_fit();
         edge_remapped_.shrink_to_fit();
-        edge_crr_id_.shrink_to_fit();
+        edge_sw_template_id_.shrink_to_fit();
     }
 
     /** @brief Append 1 more RR node to the RR graph.*/
@@ -833,7 +833,7 @@ 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 crr_id);
+    void emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch, bool remapped, 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 +933,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_crr_id_, "");
+        array_rearrange(edge_sw_template_id_, "");
         array_rearrange(edge_remapped_, false);
     }
 
@@ -1101,7 +1101,7 @@ class t_rr_graph_storage {
     */
     vtr::vector<RREdgeId, bool> edge_remapped_;
 
-    vtr::vector<RREdgeId, std::string> edge_crr_id_;
+    vtr::vector<RREdgeId, std::string> edge_sw_template_id_;
 
     /** @brief
      * The following data structures are only used for tileable routing resource graph.
@@ -1167,7 +1167,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_crr_id,
+        const vtr::array_view_id<RREdgeId, const 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)
@@ -1180,7 +1180,7 @@ class t_rr_graph_view {
         , edge_src_node_(edge_src_node)
         , edge_dest_node_(edge_dest_node)
         , edge_switch_(edge_switch)
-        , edge_crr_id_(edge_crr_id)
+        , 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) {}
@@ -1369,8 +1369,8 @@ class t_rr_graph_view {
         return edge_switch_[edge];
     }
 
-    std::string edge_crr_id(RREdgeId edge) const {
-        return edge_crr_id_[edge];
+    std::string edge_sw_template_id(RREdgeId edge) const {
+        return edge_sw_template_id_[edge];
     }
 
   private:
@@ -1391,7 +1391,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_crr_id_;
+    vtr::array_view_id<RREdgeId, const 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_;

libs/librrgraph/src/base/rr_graph_view.h

@@ -515,8 +515,8 @@ class RRGraphView {
         return node_storage_.edge_source_node(id, iedge);
     }
 
-    inline std::string edge_crr_id(RREdgeId edge) const {
-        return node_storage_.edge_crr_id(edge);
+    inline std::string edge_sw_template_id(RREdgeId edge) const {
+        return node_storage_.edge_sw_template_id(edge);
     }
 
     /** @brief Check if the edge is a configurable edge 

vpr/src/base/stats.cpp

@@ -240,7 +240,7 @@ 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_crr_id(edges[0]);
+                std::string sb_id = rr_graph.edge_sw_template_id(edges[0]);
                 if (sb_id.empty()) {
                     continue;
                 }

vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h

@@ -150,16 +150,16 @@ struct Sizing {
  */
 class Connection {
   public:
-    Connection(RRNodeId sink_node, RRNodeId src_node, int delay_ps, std::string crr_id) noexcept
+    Connection(RRNodeId sink_node, RRNodeId src_node, int delay_ps, std::string sw_template_id) noexcept
         : sink_node_(sink_node)
         , src_node_(src_node)
         , delay_ps_(delay_ps)
-        , crr_id_(std::move(crr_id)) {}
+        , sw_template_id_(std::move(sw_template_id)) {}
 
     RRNodeId sink_node() const { return sink_node_; }
     RRNodeId src_node() const { return src_node_; }
     int delay_ps() const { return delay_ps_; }
-    std::string crr_id() const { return crr_id_; }
+    std::string sw_template_id() const { return sw_template_id_; }
 
     bool operator<(const Connection& other) const {
         return std::tie(sink_node_, src_node_, delay_ps_) < std::tie(other.sink_node_, other.src_node_, other.delay_ps_);
@@ -173,7 +173,7 @@ class Connection {
     RRNodeId sink_node_;
     RRNodeId src_node_;
     int delay_ps_;
-    std::string crr_id_;
+    std::string sw_template_id_;
 };
 
 // Node hash type for lookups

vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp

@@ -135,7 +135,7 @@ void CRRConnectionBuilder::build_connections_for_location(size_t x,
                     e_rr_type source_node_type = rr_graph_.node_type(source_node);
                     RRNodeId sink_node = sink_it->second;
                     e_rr_type sink_node_type = rr_graph_.node_type(sink_node);
-                    std::string crr_id = sw_block_file_name + "_" + std::to_string(row_idx) + "_" + std::to_string(col_idx);
+                    std::string sw_template_id = sw_block_file_name + "_" + std::to_string(row_idx) + "_" + std::to_string(col_idx);
                     // If the source node is an IPIN, then it should be considered as
                     // a sink of the connection.
                     if (source_node_type == e_rr_type::IPIN) {
@@ -144,7 +144,7 @@ void CRRConnectionBuilder::build_connections_for_location(size_t x,
                                                                sink_node,
                                                                source_node);
 
-                        tile_connections.emplace_back(source_node, sink_node, delay_ps, crr_id);
+                        tile_connections.emplace_back(source_node, sink_node, delay_ps, sw_template_id);
                     } else {
                         int segment_length = -1;
                         if (sink_node_type == e_rr_type::CHANX || sink_node_type == e_rr_type::CHANY) {
@@ -156,7 +156,7 @@ void CRRConnectionBuilder::build_connections_for_location(size_t x,
                                                                sink_node,
                                                                segment_length);
 
-                        tile_connections.emplace_back(sink_node, source_node, delay_ps, crr_id);
+                        tile_connections.emplace_back(sink_node, source_node, delay_ps, sw_template_id);
                     }
                 }
             }

vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp

@@ -62,6 +62,6 @@ void build_crr_gsb_track_to_track_edges(RRGraphBuilder& rr_graph_builder,
     for (const auto& connection : gsb_connections) {
         RRSwitchId rr_switch_id = find_or_create_crr_switch_id(connection.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.crr_id());
+        rr_graph_builder.create_edge_in_cache(connection.src_node(), connection.sink_node(), rr_switch_id, false, connection.sw_template_id());
     }
 }