Changes made based on suggestions from pull request

Author: helen-23

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, net_pin_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,23 +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*/
+            /* 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_id = atoi(tokens[9 + offset].c_str());
+                    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", inode);
+                              "%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_id = OPEN;
+                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->ipin = net_pin_id;
+                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;
@@ -373,7 +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->ipin = net_pin_id;
+                tptr->net_pin_index = net_pin_index;
                 tptr->iswitch = switch_id;
                 tptr->next = nullptr;
                 node_count++;

vpr/src/base/vpr_types.h

@@ -1315,15 +1315,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 ipin:    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 guarentees an unique    *
- *                   identification for each sink-type node. For non-sink-   *
- *                   type nodes and for sink-type nodes with no associated   *
- *                   net pin index, the value for this member should be set  *
- *                   to OPEN (-1).                                           *
+ *   @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
@@ -1333,7 +1334,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 ipin = OPEN;
+    int net_pin_index = OPEN;
     short iswitch;
 };
 

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,50 +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});
         }
     }
 }
 
-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,15 +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
-    // be careful: it is possible for multiple sinks to share the same node index in some cases.
-    //             rt_nodes already have pin index stored as a member, so in most cases, you do not
-    //             need this lookup. Only use this if necessary and if you are sure that a node index
-    //             can uniquely identify the node.
-    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
@@ -46,7 +37,6 @@ class Connection_based_routing_resources {
     // get a handle on the resources
     std::vector<int>& get_remaining_targets() { return remaining_targets; }
     std::vector<t_rt_node*>& get_reached_rt_sinks() { return reached_rt_sinks; }
-    vtr::vector<ClusterNetId, std::unordered_map<int, int>>& get_rr_sink_node_to_pin() { return rr_sink_node_to_pin; };
 
     bool sanity_check_lookup() const;
 

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, int target_pin, 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);
 
@@ -494,26 +494,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, int target_pin, 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, target_pin, 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));
 
@@ -530,9 +532,10 @@ t_trace* update_traceback(t_heap* hptr, int target_pin, 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, int target_pin, 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();
 
@@ -547,7 +550,7 @@ static t_trace_branch traceback_branch(int node, int target_pin, std::unordered_
     t_trace* branch_head = alloc_trace_data();
     t_trace* branch_tail = branch_head;
     branch_head->index = node;
-    branch_head->ipin = target_pin;
+    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;
 
@@ -562,7 +565,7 @@ static t_trace_branch traceback_branch(int node, int target_pin, std::unordered_
         //Add the current node to the head of traceback
         t_trace* prev_ptr = alloc_trace_data();
         prev_ptr->index = inode;
-        prev_ptr->ipin = OPEN;
+        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;
@@ -1199,7 +1202,7 @@ alloc_trace_data() {
         trace_free_head->next = nullptr;
     }
     temp_ptr = trace_free_head;
-    temp_ptr->ipin = OPEN; //default
+    temp_ptr->net_pin_index = OPEN; //default
     trace_free_head = trace_free_head->next;
     num_trace_allocated++;
     return (temp_ptr);
@@ -1296,7 +1299,7 @@ void print_route(FILE* fp, const vtr::vector<ClusterNetId, t_traceback>& traceba
 
                     //Save net pin index for sinks
                     if (rr_type == SINK) {
-                        fprintf(fp, " Net_pin_index: %d", tptr->ipin);
+                        fprintf(fp, " Net_pin_index: %d", tptr->net_pin_index);
                     }
 
                     fprintf(fp, "\n");

vpr/src/route/route_common.h

@@ -22,7 +22,10 @@ void pathfinder_update_acc_cost_and_overuse_info(float acc_fac, OveruseInfo& ove
 
 float update_pres_fac(float new_pres_fac);
 
-t_trace* update_traceback(t_heap* hptr, int target_pin, ClusterNetId net_id);
+/* Pass in the hptr starting at a SINK with target_net_pin_index, which is the net pin index corresonding *
+ * to the sink (ranging from 1 to fanout). 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);
 
 void reset_path_costs(const std::vector<int>& visited_rr_nodes);
 

vpr/src/route/route_timing.cpp

@@ -273,7 +273,6 @@ bool try_timing_driven_route_tmpl(const t_router_opts& router_opts,
     }
 
     CBRR connections_inf{};
-    VTR_ASSERT_SAFE(connections_inf.sanity_check_lookup());
 
     route_budgets budgeting_inf;
 
@@ -1386,7 +1385,7 @@ static t_rt_node* setup_routing_resources(int itry,
 
         // give lookup on the reached sinks
         for (t_rt_node* sink_node : reached_rt_sinks) {
-            rt_node_of_sink[sink_node->ipin] = sink_node;
+            rt_node_of_sink[sink_node->net_pin_index] = sink_node;
         }
 
         profiling::net_rebuild_end(num_sinks, remaining_targets.size());

vpr/src/route/route_traceback.cpp

@@ -8,11 +8,11 @@ t_traceback::t_traceback(const t_traceback& other) {
     //Deep-copy of traceback
     t_trace* prev = nullptr;
     for (t_trace* other_curr = other.head; other_curr; other_curr = other_curr->next) {
-        //VTR_LOG("Copying trace %p node: %d switch: %d pin(for sink): %d\n", other_curr, other_curr->index, other_curr->iswitch. other_curr->ipin);
+        //VTR_LOG("Copying trace %p node: %d switch: %d pin(for sink): %d\n", other_curr, other_curr->index, other_curr->iswitch. other_curr->net_pin_index);
         t_trace* curr = alloc_trace_data();
 
         curr->index = other_curr->index;
-        curr->ipin = other_curr->ipin;
+        curr->net_pin_index = other_curr->net_pin_index;
         curr->iswitch = other_curr->iswitch;
 
         if (prev) {