Merge branch 'remove_node' of https://github.com/verilog-to-routing/vtr-verilog-to-routing into add_crr

Author: amin1377

libs/librrgraph/src/base/rr_graph_builder.cpp

@@ -225,12 +225,8 @@ std::vector<RREdgeId> RRGraphBuilder::node_in_edges(RRNodeId node) const {
     return node_in_edges_[node];
 }
 
-void RRGraphBuilder::set_node_ptc_nums(RRNodeId node, const std::string& ptc_str) {
-    node_storage_.set_node_ptc_nums(node, ptc_str);
-}
-
-std::string RRGraphBuilder::node_ptc_nums_to_string(RRNodeId node) const {
-    return node_storage_.node_ptc_nums_to_string(node);
+void RRGraphBuilder::set_node_ptc_nums(RRNodeId node, const std::vector<int>& ptc_numbers) {
+    node_storage_.set_node_ptc_nums(node, ptc_numbers);
 }
 
 bool RRGraphBuilder::node_contain_multiple_ptc(RRNodeId node) const {
@@ -266,8 +262,12 @@ void RRGraphBuilder::add_track_node_to_lookup(RRNodeId node) {
             // Find the track ids using the x/y offset  
             if (e_rr_type::CHANX == node_type || e_rr_type::CHANY == node_type) {
                 const std::vector<short>& track_nums = node_storage_.node_tilable_track_nums(node);
-                ptc = (node_type == e_rr_type::CHANX) ? track_nums[x - node_storage_.node_xlow(node)] : 
-                      track_nums[y - node_storage_.node_ylow(node)];
+                if (node_type == e_rr_type::CHANX) {
+                    ptc = track_nums[x - node_storage_.node_xlow(node)];
+                } else {
+                    VTR_ASSERT_DEBUG(node_type == e_rr_type::CHANY);
+                    ptc = track_nums[y - node_storage_.node_ylow(node)];
+                }
                 node_lookup_.add_node(node, node_storage_.node_layer_low(node), x, y, node_type, ptc);
             }
         }

libs/librrgraph/src/base/rr_graph_builder.h

@@ -276,11 +276,8 @@ class RRGraphBuilder {
         node_storage_.set_node_mux_num(id, new_mux_num);
     }
 
-    /** @brief Add a list of ptc number in string (split by comma) to a given node. This function is used by rr graph reader only. */
-    void set_node_ptc_nums(RRNodeId node, const std::string& ptc_str);
-
-    /** @brief With a given node, output ptc numbers into a string (use comma as delima). This function is used by rr graph writer only. */
-    std::string node_ptc_nums_to_string(RRNodeId node) const;
+    /** @brief Add a list of ptc numbers to a given node. This function is used by rr graph reader only. */
+    void set_node_ptc_nums(RRNodeId node, const std::vector<int>& ptc_numbers);
 
     /** @brief Identify if a node contains multiple ptc numbers. It is used for tileable RR Graph and mainly used by I/O reader only. */
     bool node_contain_multiple_ptc(RRNodeId node) const;

libs/librrgraph/src/base/rr_graph_storage.cpp

@@ -186,8 +186,8 @@ void t_rr_graph_storage::init_fan_in() {
     node_fan_in_.resize(node_storage_.size(), 0);
     node_fan_in_.shrink_to_fit();
     //Walk the graph and increment fanin on all downstream nodes
-    for(const auto& edge_id : edge_dest_node_.keys()) {
-        node_fan_in_[edge_dest_node_[edge_id]] += 1;
+    for(const auto& [_, dest_node] : edge_dest_node_.pairs()) {
+        node_fan_in_[dest_node] += 1;
     }
 }
 
@@ -629,16 +629,22 @@ void t_rr_graph_storage::set_node_direction(RRNodeId id, Direction new_direction
     node_storage_[id].dir_side_.direction = new_direction;
 }
 
-void t_rr_graph_storage::set_node_ptc_nums(RRNodeId node, const std::string& ptc_str) {
+void t_rr_graph_storage::set_node_ptc_nums(RRNodeId node, const std::vector<int>& ptc_numbers) {
     VTR_ASSERT(size_t(node) < node_storage_.size());
-    std::vector<std::string> ptc_tokens = vtr::StringToken(ptc_str).split(",");
-    VTR_ASSERT(ptc_tokens.size() >= 1);
-    set_node_ptc_num(node, std::stoi(ptc_tokens[0]));
-    if (ptc_tokens.size() > 1) {
+    VTR_ASSERT(!ptc_numbers.empty());
+    // The default VTR RR graph generator assigns only one PTC number per node, which is
+    // stored in the node_ptc_ field of rr_graph_storage. However, when the tileable RR
+    // graph is used, CHANX/CHANY nodes can have multiple PTC numbers.
+    // 
+    // To satisfy VPR's requirements, we store the PTC number for offset = 0 in the
+    // node_ptc_ field, and store all PTC numbers assigned to the node in the
+    // node_tileable_track_nums_ field.
+    set_node_ptc_num(node, ptc_numbers[0]);
+    if (ptc_numbers.size() > 1) {
         VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size());
-        node_tilable_track_nums_[node].resize(ptc_tokens.size());
-        for (size_t iptc = 0; iptc < ptc_tokens.size(); iptc++) {
-            node_tilable_track_nums_[node][iptc] = std::stoi(ptc_tokens[iptc]);
+        node_tilable_track_nums_[node].resize(ptc_numbers.size());
+        for (size_t iptc = 0; iptc < ptc_numbers.size(); iptc++) {
+            node_tilable_track_nums_[node][iptc] = ptc_numbers[iptc];
         }
     }
 }
@@ -650,33 +656,17 @@ void t_rr_graph_storage::add_node_tilable_track_num(RRNodeId node, size_t node_o
                    "Track number valid only for CHANX/CHANY RR nodes");
 
     size_t node_length = std::abs(node_xhigh(node) - node_xlow(node))
-                       + std::abs(node_yhigh(node) - node_ylow(node));
-    if (node_length + 1 != node_tilable_track_nums_[node].size()) {
-        node_tilable_track_nums_[node].resize(node_length + 1);
-    }
+                       + std::abs(node_yhigh(node) - node_ylow(node))
+                       + 1;
+    VTR_ASSERT(node_offset < node_length);
 
-    VTR_ASSERT(node_offset < node_tilable_track_nums_[node].size());
+    if (node_length != node_tilable_track_nums_[node].size()) {
+        node_tilable_track_nums_[node].resize(node_length);
+    }
 
     node_tilable_track_nums_[node][node_offset] = track_id;
 }
 
-std::string t_rr_graph_storage::node_ptc_nums_to_string(RRNodeId node) const {
-    if (node_tilable_track_nums_.empty()) {
-        return std::to_string(size_t(node_ptc_num(node)));
-    }
-    VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size());
-    if (node_tilable_track_nums_[node].empty()) {
-        return std::to_string(size_t(node_ptc_num(node)));
-    }
-    std::string ret;
-    for (size_t iptc = 0; iptc < node_tilable_track_nums_[node].size(); iptc++) {
-        ret += std::to_string(size_t(node_tilable_track_nums_[node][iptc])) + ",";
-    }
-    // Remove the last comma
-    ret.pop_back();
-    return ret;
-}
-
 void t_rr_graph_storage::add_node_side(RRNodeId id, e_side new_side) {
     if (node_type(id) != e_rr_type::IPIN && node_type(id) != e_rr_type::OPIN) {
         VTR_LOG_ERROR("Attempted to set RR node 'side' for non-pin type '%s'", node_type_string(id));
@@ -703,26 +693,26 @@ void t_rr_graph_storage::set_virtual_clock_network_root_idx(RRNodeId virtual_clo
     }
 }
 
-void t_rr_graph_storage::remove_nodes(const std::vector<RRNodeId>& nodes) {
+void t_rr_graph_storage::remove_nodes(std::vector<RRNodeId> nodes_to_remove) {
     VTR_ASSERT(!edges_read_);
+    VTR_ASSERT(!partitioned_);
     // To remove the nodes, we first sort them in ascending order. This makes it easy 
     // to calculate the offset by which other node IDs need to be adjusted. 
     // For example, after sorting the nodes to be removed, if a node ID falls between 
     // the first and second element, its ID should be reduced by 1. 
     // If a node ID is larger than the last element, its ID should be reduced by 
     // the total number of nodes being removed.
-    std::vector<RRNodeId> sorted_nodes = nodes;
-    std::sort(sorted_nodes.begin(), sorted_nodes.end());
+    std::sort(nodes_to_remove.begin(), nodes_to_remove.end());
 
     // Iterate over the nodes to be removed and adjust the IDs of nodes 
     // that fall between them. 
-    for (size_t i = 0; i < sorted_nodes.size(); ++i) {
-        size_t start_rr_node_index = size_t(sorted_nodes[i]) + 1;
-        size_t end_rr_node_index = (i == sorted_nodes.size() - 1) ? node_storage_.size() : size_t(sorted_nodes[i + 1]);
-        for (size_t j = start_rr_node_index; j < end_rr_node_index; ++j) {
-            RRNodeId old_node = RRNodeId(j);
+    for (size_t removal_idx = 0; removal_idx < nodes_to_remove.size(); ++removal_idx) {
+        size_t start_rr_node_index = size_t(nodes_to_remove[removal_idx]) + 1;
+        size_t end_rr_node_index = (removal_idx == nodes_to_remove.size() - 1) ? node_storage_.size() : size_t(nodes_to_remove[removal_idx + 1]);
+        for (size_t node_idx = start_rr_node_index; node_idx < end_rr_node_index; ++node_idx) {
+            RRNodeId old_node = RRNodeId(node_idx);
             // New node index is equal to the old nodex index minus the number of nodes being removed before it.
-            RRNodeId new_node = RRNodeId(j-(i+1));
+            RRNodeId new_node = RRNodeId(node_idx-(removal_idx+1));
             node_storage_[new_node] = node_storage_[old_node];
             node_ptc_[new_node] = node_ptc_[old_node];
             node_layer_[new_node] = node_layer_[old_node];
@@ -736,11 +726,15 @@ void t_rr_graph_storage::remove_nodes(const std::vector<RRNodeId>& nodes) {
     }
 
     // Now that the data structures are adjusted, we can shrink the size of them
-    size_t num_nodes_to_remove = sorted_nodes.size();
+    size_t num_nodes_to_remove = nodes_to_remove.size();
     VTR_ASSERT(num_nodes_to_remove <= node_storage_.size());
     node_storage_.erase(node_storage_.end()-num_nodes_to_remove, node_storage_.end());
     node_ptc_.erase(node_ptc_.end()-num_nodes_to_remove, node_ptc_.end());
     node_layer_.erase(node_layer_.end()-num_nodes_to_remove, node_layer_.end());
+    // After shifting the IDs of nodes that are not removed to the left, the last
+    // `num_nodes_to_remove` node IDs become invalid (their names have already been
+    // updated for other nodes). Therefore, the corresponding entries in `node_name_`
+    // must be removed.
     for (size_t node_index = node_name_.size()-num_nodes_to_remove; node_index < node_name_.size(); ++node_index) {
         RRNodeId node = RRNodeId(node_index);
         node_name_.erase(node);
@@ -752,19 +746,25 @@ void t_rr_graph_storage::remove_nodes(const std::vector<RRNodeId>& nodes) {
     }
 
     std::vector<RREdgeId> removed_edges;
+    // This function iterates over edge_src_node_ and edge_dest_node_ to remove
+    // entries where either endpoint of an edge is in the nodes_to_remove list.
+    // It also updates the node IDs of the remaining edges, since node IDs have
+    // been shifted.
     auto adjust_edges = [&](vtr::vector<RREdgeId, RRNodeId>& edge_nodes) {
         for (size_t edge_index = 0; edge_index < edge_nodes.size(); ++edge_index) {
             RREdgeId edge_id = RREdgeId(edge_index);
             RRNodeId node = edge_nodes[edge_id];
 
             // Find insertion point in the sorted vector
-            auto node_it = std::lower_bound(sorted_nodes.begin(), sorted_nodes.end(), node);
+            auto node_it = std::lower_bound(nodes_to_remove.begin(), nodes_to_remove.end(), node);
 
-            if (node_it != sorted_nodes.end() && *node_it == node) {
-                // Node exists in sorted_nodes, mark edge for removal
+            if (node_it != nodes_to_remove.end() && *node_it == node) {
+                // Node exists in nodes_to_remove, mark edge for removal
                 removed_edges.push_back(edge_id);
             } else {
-                size_t node_offset = std::distance(sorted_nodes.begin(), node_it);
+                // If the node is not in the nodes_to_remove list, update the node ID of the edge
+                // by finding how many nodes are there in nodes_to_remove before the node.
+                size_t node_offset = std::distance(nodes_to_remove.begin(), node_it);
                 size_t new_node_index = size_t(node) - node_offset;
                 edge_nodes[edge_id] = RRNodeId(new_node_index);
             }

libs/librrgraph/src/base/rr_graph_storage.h

@@ -705,10 +705,20 @@ class t_rr_graph_storage {
     void set_node_capacity(RRNodeId, short new_capacity);
     void set_node_direction(RRNodeId, Direction new_direction);
 
-    void set_node_ptc_nums(RRNodeId node, const std::string& ptc_str);
-    void add_node_tilable_track_num(RRNodeId node, size_t node_offset, short track_id);
+    /**
+     * @brief Set the ptc numbers for a node.
+     * @param node The node id
+     * @param ptc_numbers The ptc numbers vector to be set for the node.
+     */
+    void set_node_ptc_nums(RRNodeId node, const std::vector<int>& ptc_numbers);
 
-    void emplace_back_node_tilable_track_num();
+    /**
+     * @brief Add a track number to a node.
+     * @param node The node id
+     * @param node_offset The offset of the node from the beginning of the node.
+     * @param track_id The track number (ptc number) of the node at the given offset.
+     */
+    void add_node_tilable_track_num(RRNodeId node, size_t node_offset, short track_id);
 
     bool node_contain_multiple_ptc(RRNodeId node) const {
         if (node_tilable_track_nums_.empty()) {
@@ -718,8 +728,6 @@ class t_rr_graph_storage {
         }
     }
 
-    std::string node_ptc_nums_to_string(RRNodeId node) const;
-
     const std::vector<short>& node_tilable_track_nums(RRNodeId node) const {
         return node_tilable_track_nums_[node];
     }
@@ -743,10 +751,13 @@ class t_rr_graph_storage {
      * If init_fan_in has been called, you need to call it again after removing the nodes.
      * @note This a very expensive method, so should be called only when necessary. It is better
      * to not add nodes in the first place, instead of relying on this method to remove nodes.
+     * 
+     * @note This operation is O(|V| + |E|·log k), where k is the number of nodes to remove,
+     * and should not be called frequently.
      *
-     * @param nodes list of RRNodes to be removed
+     * @param nodes_to_remove list of RRNodes to be removed
      */
-    void remove_nodes(const std::vector<RRNodeId>& nodes);
+    void remove_nodes(std::vector<RRNodeId> nodes_to_remove);
 
     /****************
      * Edge methods *

libs/librrgraph/src/base/rr_graph_utils.cpp

@@ -390,4 +390,30 @@ bool chan_same_type_are_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RR
     }
 
     return false; // unreachable
-}
+}
+
+std::vector<int> parse_ptc_numbers(const std::string& ptc_str) {
+    std::vector<int> ptc_numbers;
+    std::vector<std::string> ptc_tokens = vtr::StringToken(ptc_str).split(",");
+    for (const std::string& ptc_token : ptc_tokens) {
+        ptc_numbers.push_back(std::stoi(ptc_token));
+    }
+    return ptc_numbers;
+}
+
+std::string node_ptc_number_to_string(const RRGraphView& rr_graph, RRNodeId node) {
+    const t_rr_graph_storage& node_storage = rr_graph.rr_nodes();
+
+    if (!node_storage.node_contain_multiple_ptc(node)) {
+        return std::to_string(size_t(node_storage.node_ptc_num(node)));
+    }
+
+    std::string ret;
+    const std::vector<short>& track_nums = node_storage.node_tilable_track_nums(node);
+    for (size_t iptc = 0; iptc < track_nums.size(); iptc++) {
+        ret += std::to_string(track_nums[iptc]) + ",";
+    }
+    // Remove the last comma
+    ret.pop_back();
+    return ret;
+}

libs/librrgraph/src/base/rr_graph_utils.h

@@ -125,3 +125,17 @@ bool chanxy_chanz_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RRNodeId
 
 bool chan_same_type_are_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RRNodeId node2);
 
+/**
+ * @brief Parse the ptc numbers string into a vector of integers.
+ * @param ptc_str The ptc numbers string in the format of "ptc1,ptc2,ptc3,...ptcn".
+ * @return A vector of integers representing the ptc numbers.
+ */
+std::vector<int> parse_ptc_numbers(const std::string& ptc_str);
+
+/**
+ * @brief Convert the ptc numbers of a node to a string.
+ * @param rr_graph The routing resource graph
+ * @param node The node id
+ * @return A string representing the ptc numbers of the node in the format of "ptc1,ptc2,ptc3,...ptcn".
+ */
+std::string node_ptc_number_to_string(const RRGraphView& rr_graph, RRNodeId node);

libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h

@@ -713,11 +713,12 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
     inline void set_node_loc_ptc(const char* ptc, int& inode) final {
         t_rr_node node = (*rr_nodes_)[inode];
         RRNodeId node_id = node.id();
-        return rr_graph_builder_->set_node_ptc_nums(node_id, std::string(ptc));
+        std::vector<int> ptc_numbers = parse_ptc_numbers(ptc);
+        return rr_graph_builder_->set_node_ptc_nums(node_id, ptc_numbers);
     }
 
     inline const char* get_node_loc_ptc(const t_rr_node& node) final {
-        temp_string_ = rr_graph_builder_->node_ptc_nums_to_string(node.id());
+        temp_string_ = node_ptc_number_to_string(*rr_graph_, node.id());
         return temp_string_.c_str();
     }
     inline int get_node_loc_layer_low(const t_rr_node& node) final {