Merge pull request #1508 from verilog-to-routing/refactor_rt_node

Refactor rt node

Author: vaughnbetz

utils/route_diag/src/main.cpp

@@ -112,7 +112,7 @@ static void do_one_route(int source_node, int sink_node,
     if (found_path) {
         VTR_ASSERT(cheapest.index == sink_node);
 
-        t_rt_node* rt_node_of_sink = update_route_tree(&cheapest, nullptr);
+        t_rt_node* rt_node_of_sink = update_route_tree(&cheapest, OPEN, nullptr);
 
         //find delay
         float net_delay = rt_node_of_sink->Tdel;

vpr/src/base/read_route.cpp

@@ -216,7 +216,7 @@ static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* file
 
     /*remember the position of the last line in order to go back*/
     std::streampos oldpos = fp.tellg();
-    int inode, x, y, x2, y2, ptc, switch_id, offset;
+    int inode, x, y, x2, y2, ptc, switch_id, net_pin_index, offset;
     std::string prev_type;
     int node_count = 0;
     std::string input;
@@ -348,10 +348,26 @@ static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* file
                 switch_id = atoi(tokens[7 + offset].c_str());
             }
 
+            /* Process net pin index for sinks                                   *
+             * If you have an old .route file, it may not have this information  *
+             * Please check your .route file to see if it contains Net_pin_index *
+             * information for sinks. If not, plrase re-generate the routing.    */
+            if (tokens[2] == "SINK") {
+                if (tokens[8 + offset] == "Net_pin_index:") {
+                    net_pin_index = atoi(tokens[9 + offset].c_str());
+                } else {
+                    vpr_throw(VPR_ERROR_ROUTE, filename, lineno,
+                              "%d (sink) node does not have net pin index. If you are using an old .route file without this information, please re-generate the routing.", inode);
+                }
+            } else {
+                net_pin_index = OPEN; //net pin index is invalid for non-SINKs
+            }
+
             /* Allocate and load correct values to trace.head*/
             if (node_count == 0) {
                 route_ctx.trace[inet].head = alloc_trace_data();
                 route_ctx.trace[inet].head->index = inode;
+                route_ctx.trace[inet].head->net_pin_index = net_pin_index;
                 route_ctx.trace[inet].head->iswitch = switch_id;
                 route_ctx.trace[inet].head->next = nullptr;
                 tptr = route_ctx.trace[inet].head;
@@ -360,6 +376,7 @@ static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* file
                 tptr->next = alloc_trace_data();
                 tptr = tptr->next;
                 tptr->index = inode;
+                tptr->net_pin_index = net_pin_index;
                 tptr->iswitch = switch_id;
                 tptr->next = nullptr;
                 node_count++;

vpr/src/base/vpr_types.h

@@ -1344,6 +1344,16 @@ typedef std::array<vtr::NdMatrix<std::vector<int>, 3>, NUM_RR_TYPES> t_rr_node_i
  * @brief Basic element used to store the traceback (routing) of each net.
  *
  *   @param index    Array index (ID) of this routing resource node.
+ *   @param net_pin_index:    Net pin index associated with the node. This value       
+ *                            ranges from 1 to fanout [1..num_pins-1]. For cases when  
+ *                            different speed paths are taken to the same SINK for     
+ *                            different pins, node index cannot uniquely identify      
+ *                            each SINK, so the net pin index guarantees an unique     
+ *                            identification for each SINK node. For non-SINK nodes    
+ *                            and for SINK nodes with no associated net pin index      
+ *                            (i.e. special SINKs like the source of a clock tree      
+ *                            which do not correspond to an actual netlist connection),
+ *                            the value for this member should be set to OPEN (-1).
  *   @param iswitch  Index of the switch type used to go from this rr_node to
  *                   the next one in the routing.  OPEN if there is no next node
  *                   (i.e. this node is the last one (a SINK) in a branch of the
@@ -1353,6 +1363,7 @@ typedef std::array<vtr::NdMatrix<std::vector<int>, 3>, NUM_RR_TYPES> t_rr_node_i
 struct t_trace {
     t_trace* next;
     int index;
+    int net_pin_index = OPEN;
     short iswitch;
 };
 

vpr/src/route/check_route.cpp

@@ -190,8 +190,7 @@ static void check_sink(int inode, ClusterNetId net_id, bool* pin_done) {
     int ptc_num = device_ctx.rr_nodes[inode].ptc_num();
     int ifound = 0;
 
-    for (int iblk = 0; iblk < type->capacity; iblk++) {
-        ClusterBlockId bnum = place_ctx.grid_blocks[i][j].blocks[iblk]; /* Hardcoded to one cluster_ctx block*/
+    for (auto bnum : place_ctx.grid_blocks[i][j].blocks) {
         unsigned int ipin = 1;
         for (auto pin_id : cluster_ctx.clb_nlist.net_sinks(net_id)) {
             if (cluster_ctx.clb_nlist.pin_block(pin_id) == bnum) {
@@ -203,17 +202,15 @@ static void check_sink(int inode, ClusterNetId net_id, bool* pin_done) {
                     if (pin_done[ipin] == false) {
                         ifound++;
                         pin_done[ipin] = true;
+                        break;
                     }
                 }
             }
             ipin++;
         }
     }
 
-    if (ifound > 1 && is_io_type(type)) {
-        VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
-                        "in check_sink: found %d terminals of net %d of pad %d at location (%d, %d).\n", ifound, size_t(net_id), ptc_num, i, j);
-    }
+    VTR_ASSERT(ifound <= 1);
 
     if (ifound < 1) {
         VPR_FATAL_ERROR(VPR_ERROR_ROUTE,

vpr/src/route/connection_based_routing.cpp

@@ -12,8 +12,6 @@ Connection_based_routing_resources::Connection_based_routing_resources()
     , connection_criticality_tolerance{0.9f}
     , connection_delay_optimality_tolerance{1.1f} {
     /* Initialize the persistent data structures for incremental rerouting
-     * this includes rr_sink_node_to_pin, which provides pin lookup given a
-     * sink node for a specific net.
      *
      * remaining_targets will reserve enough space to ensure it won't need
      * to grow while storing the sinks that still need routing after pruning
@@ -31,89 +29,26 @@ Connection_based_routing_resources::Connection_based_routing_resources()
     reached_rt_sinks.reserve(max_sink_pins_per_net);
 
     size_t routing_num_nets = cluster_ctx.clb_nlist.nets().size();
-    rr_sink_node_to_pin.resize(routing_num_nets);
     lower_bound_connection_delay.resize(routing_num_nets);
     forcible_reroute_connection_flag.resize(routing_num_nets);
 
     for (auto net_id : cluster_ctx.clb_nlist.nets()) {
-        // unordered_map<int,int> net_node_to_pin;
-        auto& net_node_to_pin = rr_sink_node_to_pin[net_id];
         auto& net_lower_bound_connection_delay = lower_bound_connection_delay[net_id];
         auto& net_forcible_reroute_connection_flag = forcible_reroute_connection_flag[net_id];
 
-        unsigned int num_pins = cluster_ctx.clb_nlist.net_pins(net_id).size();
-        net_node_to_pin.reserve(num_pins);                                                         // not looking up on the SOURCE pin
+        unsigned int num_pins = cluster_ctx.clb_nlist.net_pins(net_id).size();                     // not looking up on the SOURCE pin
         net_lower_bound_connection_delay.resize(num_pins, std::numeric_limits<float>::infinity()); // will be filled in after the 1st iteration's
         net_forcible_reroute_connection_flag.reserve(num_pins);                                    // all false to begin with
 
         for (unsigned int ipin = 1; ipin < num_pins; ++ipin) {
             // rr sink node index corresponding to this connection terminal
             auto rr_sink_node = route_ctx.net_rr_terminals[net_id][ipin];
 
-            net_node_to_pin.insert({rr_sink_node, ipin});
             net_forcible_reroute_connection_flag.insert({rr_sink_node, false});
         }
     }
 }
 
-void Connection_based_routing_resources::convert_sink_nodes_to_net_pins(std::vector<int>& rr_sink_nodes) const {
-    /* Turn a vector of device_ctx.rr_nodes indices, assumed to be of sinks for a net *
-     * into the pin indices of the same net. */
-
-    VTR_ASSERT(current_inet != ClusterNetId::INVALID()); // not uninitialized
-
-    const auto& node_to_pin_mapping = rr_sink_node_to_pin[current_inet];
-
-    for (size_t s = 0; s < rr_sink_nodes.size(); ++s) {
-        auto mapping = node_to_pin_mapping.find(rr_sink_nodes[s]);
-        if (mapping != node_to_pin_mapping.end()) {
-            rr_sink_nodes[s] = mapping->second;
-        } else {
-            VTR_ASSERT_SAFE_MSG(false, "Should always expect it find a pin mapping for its own net");
-        }
-    }
-}
-
-void Connection_based_routing_resources::put_sink_rt_nodes_in_net_pins_lookup(const std::vector<t_rt_node*>& sink_rt_nodes,
-                                                                              t_rt_node** rt_node_of_sink) const {
-    /* Load rt_node_of_sink (which maps a PIN index to a route tree node)
-     * with a vector of route tree sink nodes. */
-
-    VTR_ASSERT(current_inet != ClusterNetId::INVALID());
-
-    // a net specific mapping from node index to pin index
-    const auto& node_to_pin_mapping = rr_sink_node_to_pin[current_inet];
-
-    for (t_rt_node* rt_node : sink_rt_nodes) {
-        auto mapping = node_to_pin_mapping.find(rt_node->inode);
-
-        if (mapping != node_to_pin_mapping.end()) {
-            rt_node_of_sink[mapping->second] = rt_node;
-        } else {
-            VTR_ASSERT_SAFE_MSG(false, "element should be able to find itself");
-        }
-    }
-}
-
-bool Connection_based_routing_resources::sanity_check_lookup() const {
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& route_ctx = g_vpr_ctx.routing();
-
-    for (auto net_id : cluster_ctx.clb_nlist.nets()) {
-        const auto& net_node_to_pin = rr_sink_node_to_pin[net_id];
-
-        for (auto mapping : net_node_to_pin) {
-            auto sanity = net_node_to_pin.find(mapping.first);
-            if (sanity == net_node_to_pin.end()) {
-                VTR_LOG("%d cannot find itself (net %lu)\n", mapping.first, size_t(net_id));
-                return false;
-            }
-            VTR_ASSERT(route_ctx.net_rr_terminals[net_id][mapping.second] == mapping.first);
-        }
-    }
-    return true;
-}
-
 void Connection_based_routing_resources::set_lower_bound_connection_delays(ClbNetPinsMatrix<float>& net_delay) {
     /* Set the lower bound connection delays after first iteration, which only optimizes for timing delay.
      * This will be used later to judge the optimality of a connection, with suboptimal ones being candidates

vpr/src/route/connection_based_routing.h

@@ -15,11 +15,6 @@
 // reroute only the connections to the ones that did not have a legal connection the previous time
 class Connection_based_routing_resources {
     // Incremental reroute resources --------------
-    // conceptually works like rr_sink_node_to_pin[inet][sink_rr_node_index] to get the pin index for that net
-    // each net maps SINK node index -> PIN index for net
-    // only need to be built once at the start since the SINK nodes never change
-    // the reverse lookup of route_ctx.net_rr_terminals
-    vtr::vector<ClusterNetId, std::unordered_map<int, int>> rr_sink_node_to_pin;
 
     // a property of each net, but only valid after pruning the previous route tree
     // the "targets" in question can be either rr_node indices or pin indices, the
@@ -43,11 +38,6 @@ class Connection_based_routing_resources {
     std::vector<int>& get_remaining_targets() { return remaining_targets; }
     std::vector<t_rt_node*>& get_reached_rt_sinks() { return reached_rt_sinks; }
 
-    void convert_sink_nodes_to_net_pins(std::vector<int>& rr_sink_nodes) const;
-
-    void put_sink_rt_nodes_in_net_pins_lookup(const std::vector<t_rt_node*>& sink_rt_nodes,
-                                              t_rt_node** rt_node_of_sink) const;
-
     bool sanity_check_lookup() const;
 
     void set_connection_criticality_tolerance(float val) { connection_criticality_tolerance = val; }

vpr/src/route/route_breadth_first.cpp

@@ -265,7 +265,8 @@ static bool breadth_first_route_net(BinaryHeap& heap, ClusterNetId net_id, float
 
         route_ctx.rr_node_route_inf[inode].target_flag--; /* Connected to this SINK. */
         remaining_connections_to_sink = route_ctx.rr_node_route_inf[inode].target_flag;
-        tptr = update_traceback(current, net_id);
+        size_t ipin = cluster_ctx.clb_nlist.pin_net_index(pin_id);
+        tptr = update_traceback(current, ipin, net_id);
         heap.free(current);
     }
 

vpr/src/route/route_common.cpp

@@ -86,7 +86,7 @@ static int num_linked_f_pointer_allocated = 0;
  *                                                                          */
 
 /******************** Subroutines local to route_common.c *******************/
-static t_trace_branch traceback_branch(int node, std::unordered_set<int>& main_branch_visited);
+static t_trace_branch traceback_branch(int node, int target_net_pin_index, std::unordered_set<int>& main_branch_visited);
 static std::pair<t_trace*, t_trace*> add_trace_non_configurable(t_trace* head, t_trace* tail, int node, std::unordered_set<int>& visited);
 static std::pair<t_trace*, t_trace*> add_trace_non_configurable_recurr(int node, std::unordered_set<int>& visited, int depth = 0);
 
@@ -484,26 +484,28 @@ void init_route_structs(int bb_factor) {
     route_ctx.net_status.resize(cluster_ctx.clb_nlist.nets().size());
 }
 
-t_trace* update_traceback(t_heap* hptr, ClusterNetId net_id) {
-    /* This routine adds the most recently finished wire segment to the         *
-     * traceback linked list.  The first connection starts with the net SOURCE  *
-     * and begins at the structure pointed to by route_ctx.trace[net_id].head.  *
-     * Each connection ends with a SINK.  After each SINK, the next connection  *
-     * begins (if the net has more than 2 pins).  The first element after the   *
-     * SINK gives the routing node on a previous piece of the routing, which is *
-     * the link from the existing net to this new piece of the net.             *
-     * In each traceback I start at the end of a path and trace back through    *
-     * its predecessors to the beginning.  I have stored information on the     *
-     * predecesser of each node to make traceback easy -- this sacrificies some *
-     * memory for easier code maintenance.  This routine returns a pointer to   *
-     * the first "new" node in the traceback (node not previously in trace).    */
+/* This routine adds the most recently finished wire segment to the         *
+ * traceback linked list.  The first connection starts with the net SOURCE  *
+ * and begins at the structure pointed to by route_ctx.trace[net_id].head.  *
+ * Each connection ends with a SINK.  After each SINK, the next connection  *
+ * begins (if the net has more than 2 pins).  The first element after the   *
+ * SINK gives the routing node on a previous piece of the routing, which is *
+ * the link from the existing net to this new piece of the net.             *
+ * In each traceback I start at the end of a path, which is a SINK with     *
+ * target_net_pin_index (net pin index corresponding to the SINK, ranging   *
+ * from 1 to fanout), and trace back through its predecessors to the        *
+ * beginning.  I have stored information on the predecesser of each node to *
+ * make traceback easy -- this sacrificies some memory for easier code      *
+ * maintenance.  This routine returns a pointer to the first "new" node in  *
+ * the traceback (node not previously in trace).                            */
+t_trace* update_traceback(t_heap* hptr, int target_net_pin_index, ClusterNetId net_id) {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
 
     auto& trace_nodes = route_ctx.trace_nodes[net_id];
 
     VTR_ASSERT_SAFE(validate_trace_nodes(route_ctx.trace[net_id].head, trace_nodes));
 
-    t_trace_branch branch = traceback_branch(hptr->index, trace_nodes);
+    t_trace_branch branch = traceback_branch(hptr->index, target_net_pin_index, trace_nodes);
 
     VTR_ASSERT_SAFE(validate_trace_nodes(branch.head, trace_nodes));
 
@@ -520,9 +522,10 @@ t_trace* update_traceback(t_heap* hptr, ClusterNetId net_id) {
     return (ret_ptr);
 }
 
-//Traces back a new routing branch starting from the specified 'node' and working backwards to any existing routing.
+//Traces back a new routing branch starting from the specified SINK 'node' with target_net_pin_index, which is the
+//net pin index corresponding to the SINK (ranging from 1 to fanout), and working backwards to any existing routing.
 //Returns the new branch, and also updates trace_nodes for any new nodes which are included in the branches traceback.
-static t_trace_branch traceback_branch(int node, std::unordered_set<int>& trace_nodes) {
+static t_trace_branch traceback_branch(int node, int target_net_pin_index, std::unordered_set<int>& trace_nodes) {
     auto& device_ctx = g_vpr_ctx.device();
     auto& route_ctx = g_vpr_ctx.routing();
 
@@ -537,6 +540,7 @@ static t_trace_branch traceback_branch(int node, std::unordered_set<int>& trace_
     t_trace* branch_head = alloc_trace_data();
     t_trace* branch_tail = branch_head;
     branch_head->index = node;
+    branch_head->net_pin_index = target_net_pin_index; //The first node is the SINK node, so store its net pin index
     branch_head->iswitch = OPEN;
     branch_head->next = nullptr;
 
@@ -551,6 +555,7 @@ static t_trace_branch traceback_branch(int node, std::unordered_set<int>& trace_
         //Add the current node to the head of traceback
         t_trace* prev_ptr = alloc_trace_data();
         prev_ptr->index = inode;
+        prev_ptr->net_pin_index = OPEN; //Net pin index is invalid for Non-SINK nodes
         prev_ptr->iswitch = device_ctx.rr_nodes.edge_switch(iedge);
         prev_ptr->next = branch_head;
         branch_head = prev_ptr;
@@ -731,11 +736,16 @@ void mark_ends(ClusterNetId net_id) {
     }
 }
 
-void mark_remaining_ends(const std::vector<int>& remaining_sinks) {
+void mark_remaining_ends(ClusterNetId net_id, const std::vector<int>& remaining_sinks) {
     // like mark_ends, but only performs it for the remaining sinks of a net
+    int inode;
+
     auto& route_ctx = g_vpr_ctx.mutable_routing();
-    for (int sink_node : remaining_sinks)
-        ++route_ctx.rr_node_route_inf[sink_node].target_flag;
+
+    for (int sink_pin : remaining_sinks) {
+        inode = route_ctx.net_rr_terminals[net_id][sink_pin];
+        ++route_ctx.rr_node_route_inf[inode].target_flag;
+    }
 }
 
 void drop_traceback_tail(ClusterNetId net_id) {
@@ -1182,6 +1192,7 @@ alloc_trace_data() {
         trace_free_head->next = nullptr;
     }
     temp_ptr = trace_free_head;
+    temp_ptr->net_pin_index = OPEN; //default
     trace_free_head = trace_free_head->next;
     num_trace_allocated++;
     return (temp_ptr);
@@ -1276,6 +1287,11 @@ void print_route(FILE* fp, const vtr::vector<ClusterNetId, t_traceback>& traceba
                      * used in the routing.                                                      */
                     fprintf(fp, "Switch: %d", tptr->iswitch);
 
+                    //Save net pin index for sinks
+                    if (rr_type == SINK) {
+                        fprintf(fp, " Net_pin_index: %d", tptr->net_pin_index);
+                    }
+
                     fprintf(fp, "\n");
 
                     tptr = tptr->next;