Merge branch 'master' into noc_turn_model_routing

Author: soheilshahrouz

doc/src/vpr/command_line_usage.rst

@@ -350,7 +350,7 @@ Use the options below to override this default naming behaviour.
 
 .. option:: --read_rr_graph <file>
 
-    Reads in the routing resource graph named <file> loads it for use during the placement and routing stages. Expects a file extension of either ``.xml`` and ``.bin``.
+    Reads in the routing resource graph named <file> loads it for use during the placement and routing stages. Expects a file extension of either ``.xml`` or ``.bin``.
 
     The routing resource graph overthrows all the architecture definitions regarding switches, nodes, and edges. Other information such as grid information, block types, and segment information are matched with the architecture file to ensure accuracy.
 
@@ -368,22 +368,22 @@ Use the options below to override this default naming behaviour.
 
 .. option:: --read_router_lookahead <file>
 
-    Reads the lookahead data from the specified file instead of computing it.
+    Reads the lookahead data from the specified file instead of computing it. Expects a file extension of either ``.capnp`` or ``.bin``.
 
 .. option:: --write_router_lookahead <file>
 
-    Writes the lookahead data to the specified file.
+    Writes the lookahead data to the specified file. Accepted file extensions are ``.capnp``, ``.bin``, and ``.csv``.
 
 .. option:: --read_placement_delay_lookup <file>
 
-    Reads the placement delay lookup from the specified file instead of computing it.
+    Reads the placement delay lookup from the specified file instead of computing it. Expects a file extension of either ``.capnp`` or ``.bin``.
 
 .. option:: --write_placement_delay_lookup <file>
 
-    Writes the placement delay lookup to the specified file.
+    Writes the placement delay lookup to the specified file. Expects a file extension of either ``.capnp`` or ``.bin``.
 .. option:: --write_initial_place_file <file>
 
-    Writes out the the placement chosen by the initial placement algorithm to the specified file
+    Writes out the the placement chosen by the initial placement algorithm to the specified file.
 
 .. option:: --outfile_prefix <string>
 

vpr/src/route/route_common.cpp

@@ -190,6 +190,28 @@ void pathfinder_update_acc_cost_and_overuse_info(float acc_fac, OveruseInfo& ove
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
     auto& route_ctx = g_vpr_ctx.mutable_routing();
+
+#ifdef VPR_USE_TBB
+    tbb::combinable<size_t> overused_nodes(0), total_overuse(0), worst_overuse(0);
+    tbb::parallel_for_each(rr_graph.nodes().begin(), rr_graph.nodes().end(), [&](RRNodeId rr_id) {
+        int overuse = route_ctx.rr_node_route_inf[rr_id].occ() - rr_graph.node_capacity(rr_id);
+
+        // If overused, update the acc_cost and add this node to the overuse info
+        // If not, do nothing
+        if (overuse > 0) {
+            route_ctx.rr_node_route_inf[rr_id].acc_cost += overuse * acc_fac;
+
+            ++overused_nodes.local();
+            total_overuse.local() += overuse;
+            worst_overuse.local() = std::max(worst_overuse.local(), size_t(overuse));
+        }
+    });
+
+    // Update overuse info
+    overuse_info.overused_nodes = overused_nodes.combine(std::plus<size_t>());
+    overuse_info.total_overuse = total_overuse.combine(std::plus<size_t>());
+    overuse_info.worst_overuse = worst_overuse.combine([](size_t a, size_t b) { return std::max(a, b); });
+#else
     size_t overused_nodes = 0, total_overuse = 0, worst_overuse = 0;
 
     for (const RRNodeId& rr_id : rr_graph.nodes()) {
@@ -210,6 +232,7 @@ void pathfinder_update_acc_cost_and_overuse_info(float acc_fac, OveruseInfo& ove
     overuse_info.overused_nodes = overused_nodes;
     overuse_info.total_overuse = total_overuse;
     overuse_info.worst_overuse = worst_overuse;
+#endif
 }
 
 /** Update pathfinder cost of all nodes rooted at rt_node, including rt_node itself */

vpr/src/route/route_net.cpp

@@ -251,6 +251,23 @@ WirelengthInfo calculate_wirelength_info(const Netlist<>& net_list, size_t avail
 
     auto& route_ctx = g_vpr_ctx.routing();
 
+#ifdef VPR_USE_TBB
+    tbb::combinable<size_t> thread_used_wirelength(0);
+
+    tbb::parallel_for_each(net_list.nets().begin(), net_list.nets().end(), [&](ParentNetId net_id) {
+        if (!net_list.net_is_ignored(net_id)
+            && net_list.net_sinks(net_id).size() != 0 /* Globals don't count. */
+            && route_ctx.route_trees[net_id]) {
+            int bends, wirelength, segments;
+            bool is_absorbed;
+            get_num_bends_and_length(net_id, &bends, &wirelength, &segments, &is_absorbed);
+
+            thread_used_wirelength.local() += wirelength;
+        }
+    });
+
+    used_wirelength = thread_used_wirelength.combine(std::plus<size_t>());
+#else
     for (auto net_id : net_list.nets()) {
         if (!net_list.net_is_ignored(net_id)
             && net_list.net_sinks(net_id).size() != 0 /* Globals don't count. */
@@ -262,6 +279,7 @@ WirelengthInfo calculate_wirelength_info(const Netlist<>& net_list, size_t avail
             used_wirelength += wirelength;
         }
     }
+#endif
 
     return WirelengthInfo(available_wirelength, used_wirelength);
 }

vpr/src/route/router_lookahead_map.cpp

@@ -463,7 +463,7 @@ void MapLookahead::write(const std::string& file_name) const {
         }
         dump_readable_router_lookahead_map(file_name, wire_cost_map_size, get_wire_cost_entry);
     } else {
-        VTR_ASSERT(vtr::check_file_name_extension(file_name, ".capnp"));
+        VTR_ASSERT(vtr::check_file_name_extension(file_name, ".capnp") || vtr::check_file_name_extension(file_name, ".bin"));
         write_router_lookahead(file_name);
     }
 }

vpr/src/route/router_lookahead_map_utils.cpp

@@ -26,7 +26,7 @@ static void dijkstra_flood_to_ipins(RRNodeId node, util::t_chan_ipins_delays& ch
  * @param itile
  * @return Return the maximum ptc number of the SOURCE/OPINs of a tile type
  */
-static int get_tile_src_opin_max_ptc_from_rr_graph(int itile);
+static int get_tile_src_opin_max_ptc(int itile);
 
 static t_physical_tile_loc pick_sample_tile(int layer_num, t_physical_tile_type_ptr tile_type, t_physical_tile_loc prev);
 
@@ -338,7 +338,7 @@ t_src_opin_delays compute_router_src_opin_lookahead(bool is_flat) {
 
     // Get the maximum OPIN ptc for each tile type to reserve src_opin_delays
     for (int itile = 0; itile < (int)device_ctx.physical_tile_types.size(); itile++) {
-        tile_max_ptc[itile] = get_tile_src_opin_max_ptc_from_rr_graph(itile);
+        tile_max_ptc[itile] = get_tile_src_opin_max_ptc(itile);
     }
 
     // Resize src_opin_delays to accomodate enough ptc and layer
@@ -1114,55 +1114,19 @@ static void dijkstra_flood_to_ipins(RRNodeId node, util::t_chan_ipins_delays& ch
     }
 }
 
-static int get_tile_src_opin_max_ptc_from_rr_graph(int itile) {
+static int get_tile_src_opin_max_ptc(int itile) {
     const auto& device_ctx = g_vpr_ctx.device();
     const auto& physical_tile = device_ctx.physical_tile_types[itile];
-    const auto& rr_graph = device_ctx.rr_graph;
-    const int num_layers = device_ctx.grid.get_num_layers();
-    int max_ptc = OPEN;
+    int max_ptc = 0;
 
-    // Find a layer that has instances of the tile type
-    int tile_layer_num = OPEN;
-    for (int layer_num = 0; layer_num < num_layers; layer_num++) {
-        if (device_ctx.grid.num_instances(&physical_tile, layer_num) > 0) {
-            tile_layer_num = layer_num;
-            break;
+    // Output pin
+    for (const auto& class_inf: physical_tile.class_inf) {
+        if (class_inf.type != e_pin_type::DRIVER) {
+            continue;
         }
-    }
-
-    if (tile_layer_num == OPEN) {
-        VTR_LOG_WARN("Found no sample locations for %s\n",
-                     physical_tile.name);
-        max_ptc = OPEN;
-    } else {
-        for (e_rr_type rr_type : {SOURCE, OPIN}) {
-            t_physical_tile_loc sample_loc(OPEN, OPEN, OPEN);
-            sample_loc = pick_sample_tile(tile_layer_num, &physical_tile, sample_loc);
-
-            if (sample_loc.x == OPEN && sample_loc.y == OPEN && sample_loc.layer_num == OPEN) {
-                //No untried instances of the current tile type left
-                VTR_LOG_WARN("Found no sample locations for %s in %s\n",
-                             rr_node_typename[rr_type],
-                             physical_tile.name);
-                return OPEN;
-            }
-
-            const std::vector<RRNodeId>& rr_nodes_at_loc = device_ctx.rr_graph.node_lookup().find_grid_nodes_at_all_sides(sample_loc.layer_num,
-                                                                                                                          sample_loc.x,
-                                                                                                                          sample_loc.y,
-                                                                                                                          rr_type);
-            for (RRNodeId node_id : rr_nodes_at_loc) {
-                int ptc = rr_graph.node_ptc_num(node_id);
-                // For the time being, we decide to not let the lookahead explore the node inside the clusters
-                if (!is_inter_cluster_node(&physical_tile,
-                                           rr_type,
-                                           ptc)) {
-                    continue;
-                }
-
-                if (ptc >= max_ptc) {
-                    max_ptc = ptc;
-                }
+        for (const auto& pin_ptc : class_inf.pinlist) {
+            if (pin_ptc > max_ptc) {
+                max_ptc = pin_ptc;
             }
         }
     }