Merge branch 'master' into yosys+odin

Author: vaughnbetz

utils/route_diag/src/main.cpp

@@ -102,6 +102,7 @@ static void do_one_route(int source_node, int sink_node,
             device_ctx.grid,
             *router_lookahead,
             device_ctx.rr_nodes,
+            &device_ctx.rr_graph,
             device_ctx.rr_rc_data,
             device_ctx.rr_switch_inf,
             g_vpr_ctx.mutable_routing().rr_node_route_inf);

vpr/asan.supp

@@ -0,0 +1,5 @@
+#AddressSanitizer suppression file for VPR
+
+#Suppress known errors from the TBB library
+#These are some errors from the library that we can't fix and suspect are spurious
+interceptor_via_lib:libtbb.so

vpr/lsan.supp

@@ -1,5 +1,8 @@
-#LeakSanitizer supporession file for VPR
+#LeakSanitizer suppression file for VPR
 
 #Leak from graphics (ezgl/cairo) related to
 # text processing
 leak:libfontconfig.so
+#Leaks from TBB library, which
+#allows VPR to run with parallelism
+leak:libtbb.so

vpr/src/base/vpr_context.h

@@ -160,26 +160,15 @@ struct DeviceContext : public Context {
     ///@brief Reverse look-up from RR node to non-configurably connected node set (index into rr_nonconf_node_sets)
     std::unordered_map<int, int> rr_node_to_non_config_node_set;
 
-    ///@brief The indicies of rr nodes of a given type at a specific x,y grid location
-    t_rr_node_indices rr_node_indices; // [0..NUM_RR_TYPES-1][0..grid.width()-1][0..grid.width()-1][0..size-1]
-
-    /* TODO: remove this interface from device_context once the code refactoring is completed
-     * because it should be part of the rr_graph view
-     * TODO: Currently, we use reference pointers to ensure that the rr_spatial_lookup is always
-     * synchronized with the rr_node_indices but this causes a lot of confusion for developers
-     * The temporary fix should be patched as soon as possible.
+    /* A writeable view of routing resource graph to be the ONLY database 
+     * for routing resource graph builder functions.
      */
-    RRSpatialLookup rr_spatial_lookup{rr_node_indices};
+    RRGraphBuilder rr_graph_builder{&rr_nodes};
 
     /* A read-only view of routing resource graph to be the ONLY database 
      * for client functions: GUI, placer, router, timing analyzer etc.
      */
-    RRGraphView rr_graph{rr_nodes, rr_spatial_lookup};
-
-    /* A writeable view of routing resource graph to be the ONLY database 
-     * for routing resource graph builder functions.
-     */
-    RRGraphBuilder rr_graph_builder{&rr_nodes, &rr_spatial_lookup};
+    RRGraphView rr_graph{rr_nodes, rr_graph_builder.node_lookup()};
 
     ///@brief Autogenerated in build_rr_graph based on switch fan-in. [0..(num_rr_switches-1)]
     std::vector<t_rr_switch_inf> rr_switch_inf;

vpr/src/device/rr_graph_builder.cpp

@@ -1,10 +1,8 @@
 #include "vtr_log.h"
 #include "rr_graph_builder.h"
 
-RRGraphBuilder::RRGraphBuilder(t_rr_graph_storage* node_storage,
-                               RRSpatialLookup* node_lookup)
-    : node_storage_(*node_storage)
-    , node_lookup_(*node_lookup) {
+RRGraphBuilder::RRGraphBuilder(t_rr_graph_storage* node_storage)
+    : node_storage_(*node_storage) {
 }
 
 t_rr_graph_storage& RRGraphBuilder::node_storage() {
@@ -48,3 +46,7 @@ void RRGraphBuilder::add_node_to_all_locs(RRNodeId node) {
         }
     }
 }
+
+void RRGraphBuilder::clear() {
+    node_lookup_.clear();
+}

vpr/src/device/rr_graph_builder.h

@@ -19,8 +19,7 @@ class RRGraphBuilder {
     /* -- Constructors -- */
   public:
     /* See detailed comments about the data structures in the internal data storage section of this file */
-    RRGraphBuilder(t_rr_graph_storage* node_storage,
-                   RRSpatialLookup* node_lookup);
+    RRGraphBuilder(t_rr_graph_storage* node_storage);
 
     /* Disable copy constructors and copy assignment operator
      * This is to avoid accidental copy because it could be an expensive operation considering that the 
@@ -49,6 +48,9 @@ class RRGraphBuilder {
      */
     void add_node_to_all_locs(RRNodeId node);
 
+    /* Clear all the underlying data storage */
+    void clear();
+
     /* -- Internal data storage -- */
   private:
     /* TODO: When the refactoring effort finishes, 
@@ -63,7 +65,7 @@ class RRGraphBuilder {
     /* node-level storage including edge storages */
     t_rr_graph_storage& node_storage_;
     /* Fast look-up for rr nodes */
-    RRSpatialLookup& node_lookup_;
+    RRSpatialLookup node_lookup_;
 };
 
 #endif

vpr/src/device/rr_graph_obj.cpp

@@ -168,18 +168,6 @@ e_side RRGraph::node_side(const RRNodeId& node) const {
     return node_sides_[node];
 }
 
-/* Get the resistance of a node */
-float RRGraph::node_R(const RRNodeId& node) const {
-    VTR_ASSERT_SAFE(valid_node_id(node));
-    return node_Rs_[node];
-}
-
-/* Get the capacitance of a node */
-float RRGraph::node_C(const RRNodeId& node) const {
-    VTR_ASSERT_SAFE(valid_node_id(node));
-    return node_Cs_[node];
-}
-
 /*
  * Get a segment id of a node in rr_graph 
  */

vpr/src/device/rr_graph_obj.h

@@ -434,12 +434,6 @@ class RRGraph {
      */
     e_side node_side(const RRNodeId& node) const;
 
-    /* Get resistance of a node, used to built RC tree for timing analysis */
-    float node_R(const RRNodeId& node) const;
-
-    /* Get capacitance of a node, used to built RC tree for timing analysis */
-    float node_C(const RRNodeId& node) const;
-
     /* Get segment id of a node, containing the information of the routing
      * segment that the node represents. See more details in the data structure t_segment_inf
      */

vpr/src/device/rr_graph_view.h

@@ -1,8 +1,7 @@
 #ifndef RR_GRAPH_VIEW_H
 #define RR_GRAPH_VIEW_H
 
-#include "rr_graph_storage.h"
-#include "rr_spatial_lookup.h"
+#include "rr_graph_builder.h"
 
 /* An read-only routing resource graph
  * which is an unified object including pointors to
@@ -77,6 +76,21 @@ class RRGraphView {
         return node_storage_.node_direction_string(node);
     }
 
+    /* Get the capacitance of a routing resource node. This function is inlined for runtime optimization. */
+    inline float node_C(RRNodeId node) const {
+        return node_storage_.node_C(node);
+    }
+
+    /* Get the resistance of a routing resource node. This function is inlined for runtime optimization. */
+    inline float node_R(RRNodeId node) const {
+        return node_storage_.node_R(node);
+    }
+
+    /* Get the rc_index of a routing resource node. This function is inlined for runtime optimization. */
+    inline int16_t node_rc_index(RRNodeId node) const {
+        return node_storage_.node_rc_index(node);
+    }
+
     /* Get the fan in of a routing resource node. This function is inlined for runtime optimization. */
     inline t_edge_size node_fan_in(RRNodeId node) const {
         return node_storage_.fan_in(node);

vpr/src/device/rr_spatial_lookup.cpp

@@ -1,8 +1,7 @@
 #include "vtr_assert.h"
 #include "rr_spatial_lookup.h"
 
-RRSpatialLookup::RRSpatialLookup(t_rr_node_indices& rr_node_indices)
-    : rr_node_indices_(rr_node_indices) {
+RRSpatialLookup::RRSpatialLookup() {
 }
 
 RRNodeId RRSpatialLookup::find_node(int x,
@@ -273,3 +272,26 @@ void RRSpatialLookup::resize_nodes(int x,
                                        std::max(rr_node_indices_[type].dim_size(2), size_t(side) + 1)});
     }
 }
+
+void RRSpatialLookup::reorder(const vtr::vector<RRNodeId, RRNodeId> dest_order) {
+    // update rr_node_indices, a map to optimize rr_index lookups
+    for (auto& grid : rr_node_indices_) {
+        for (size_t x = 0; x < grid.dim_size(0); x++) {
+            for (size_t y = 0; y < grid.dim_size(1); y++) {
+                for (size_t s = 0; s < grid.dim_size(2); s++) {
+                    for (auto& node : grid[x][y][s]) {
+                        if (node != OPEN) {
+                            node = size_t(dest_order[RRNodeId(node)]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+void RRSpatialLookup::clear() {
+    for (auto& data : rr_node_indices_) {
+        data.clear();
+    }
+}

vpr/src/device/rr_spatial_lookup.h

@@ -2,6 +2,7 @@
 #define RR_SPATIAL_LOOKUP_H
 
 #include "vtr_geometry.h"
+#include "vtr_vector.h"
 #include "vpr_types.h"
 
 /******************************************************************** 
@@ -17,7 +18,7 @@ class RRSpatialLookup {
     /* -- Constructors -- */
   public:
     /* Explicitly define the only way to create an object */
-    explicit RRSpatialLookup(t_rr_node_indices& rr_node_indices);
+    explicit RRSpatialLookup();
 
     /* Disable copy constructors and copy assignment operator
      * This is to avoid accidental copy because it could be an expensive operation considering that the 
@@ -185,6 +186,12 @@ class RRSpatialLookup {
                       t_rr_type type,
                       e_side side);
 
+    /* Reorder the internal look up to be more memory efficient */
+    void reorder(const vtr::vector<RRNodeId, RRNodeId> dest_order);
+
+    /* Clear all the data inside */
+    void clear();
+
     /* -- Internal data queries -- */
   private:
     /* An internal API to find all the nodes in a specific location with a given type
@@ -199,17 +206,8 @@ class RRSpatialLookup {
 
     /* -- Internal data storage -- */
   private:
-    /* TODO: When the refactoring effort finishes, 
-     * the data structure will be the owner of the data storages. 
-     * That is why the reference is used here.
-     * It can avoid a lot of code changes once the refactoring is finished 
-     * (there is no function get data directly through the rr_node_indices in DeviceContext).
-     * If pointers are used, it may cause many codes in client functions 
-     * or inside the data structures to be changed later.
-     * That explains why the reference is used here temporarily
-     */
     /* Fast look-up: TODO: Should rework the data type. Currently it is based on a 3-dimensional arrqay mater where some dimensions must always be accessed with a specific index. Such limitation should be overcome */
-    t_rr_node_indices& rr_node_indices_;
+    t_rr_node_indices rr_node_indices_;
 };
 
 #endif

vpr/src/place/grid_tile_lookup.cpp

@@ -0,0 +1,143 @@
+#include "grid_tile_lookup.h"
+
+void GridTileLookup::initialize_grid_tile_matrices() {
+    auto& device_ctx = g_vpr_ctx.device();
+
+    //Will store the max number of tile locations for each logical block type
+    max_placement_locations.resize(device_ctx.logical_block_types.size());
+
+    for (const auto& type : device_ctx.logical_block_types) {
+        vtr::NdMatrix<int, 2> type_count({device_ctx.grid.width(), device_ctx.grid.height()});
+        fill_type_matrix(&type, type_count);
+        block_type_matrices.push_back(type_count);
+    }
+}
+
+void GridTileLookup::fill_type_matrix(t_logical_block_type_ptr block_type, vtr::NdMatrix<int, 2>& type_count) {
+    auto& device_ctx = g_vpr_ctx.device();
+
+    int num_rows = device_ctx.grid.height();
+    int num_cols = device_ctx.grid.width();
+
+    /*
+     * Iterating through every location on the grid to store the number of subtiles of
+     * the correct type at each location. For each location, we store the cumulative
+     * number of tiles of the type up to that location - meaning we store the number of
+     * subtiles at the location, plus the number of subtiles at the locations above and to
+     * the right of it.
+     */
+    for (int i_col = type_count.dim_size(0) - 1; i_col >= 0; i_col--) {
+        for (int j_row = type_count.dim_size(1) - 1; j_row >= 0; j_row--) {
+            auto& tile = device_ctx.grid[i_col][j_row].type;
+            type_count[i_col][j_row] = 0;
+
+            if (is_tile_compatible(tile, block_type)) {
+                for (const auto& sub_tile : tile->sub_tiles) {
+                    if (is_sub_tile_compatible(tile, block_type, sub_tile.capacity.low)) {
+                        type_count[i_col][j_row] = sub_tile.capacity.total();
+                    }
+                }
+            }
+
+            if (i_col < num_cols - 1) {
+                type_count[i_col][j_row] += type_count[i_col + 1][j_row];
+            }
+            if (j_row < num_rows - 1) {
+                type_count[i_col][j_row] += type_count[i_col][j_row + 1];
+            }
+            if (i_col < (num_cols - 1) && j_row < (num_rows - 1)) {
+                type_count[i_col][j_row] -= type_count[i_col + 1][j_row + 1];
+            }
+        }
+    }
+
+    //The total number of subtiles for the block type will be at [0][0]
+    max_placement_locations[block_type->index] = type_count[0][0];
+}
+
+vtr::NdMatrix<int, 2>& GridTileLookup::get_type_grid(t_logical_block_type_ptr block_type) {
+    return block_type_matrices[block_type->index];
+}
+
+int GridTileLookup::total_type_tiles(t_logical_block_type_ptr block_type) {
+    return max_placement_locations[block_type->index];
+}
+
+/*
+ * This routine uses pre-computed values from the grids for each block type to get the number of grid tiles
+ * covered by a region.
+ * For a region with no subtiles specified, the number of grid tiles can be calculated by adding
+ * and subtracting four values from within/at the edge of the region.
+ * The region with subtile case is taken care of by a helper routine, region_with_subtile_count().
+ */
+int GridTileLookup::region_tile_count(const Region& reg, t_logical_block_type_ptr block_type) {
+    vtr::Rect<int> reg_rect = reg.get_region_rect();
+    int subtile = reg.get_sub_tile();
+
+    int xmin = reg_rect.xmin();
+    int ymin = reg_rect.ymin();
+    int xmax = reg_rect.xmax();
+    int ymax = reg_rect.ymax();
+    auto& type_grid = block_type_matrices[block_type->index];
+
+    int xdim = type_grid.dim_size(0);
+    int ydim = type_grid.dim_size(1);
+
+    int num_tiles = 0;
+
+    if (subtile == NO_SUBTILE) {
+        num_tiles = type_grid[xmin][ymin];
+
+        if ((ymax + 1) < ydim) {
+            num_tiles -= type_grid[xmin][ymax + 1];
+        }
+
+        if ((xmax + 1) < xdim) {
+            num_tiles -= type_grid[xmax + 1][ymin];
+        }
+
+        if ((xmax + 1) < xdim && (ymax + 1) < ydim) {
+            num_tiles += type_grid[xmax + 1][ymax + 1];
+        }
+    } else {
+        num_tiles = region_with_subtile_count(reg, block_type);
+    }
+
+    return num_tiles;
+}
+
+/*
+ * This routine is for the subtile specified case; an O(region_size) scan needs to be done to check whether each grid
+ * location in the region is compatible for the block at the subtile specified.
+ */
+int GridTileLookup::region_with_subtile_count(const Region& reg, t_logical_block_type_ptr block_type) {
+    auto& device_ctx = g_vpr_ctx.device();
+    int num_sub_tiles = 0;
+    vtr::Rect<int> reg_rect = reg.get_region_rect();
+    int subtile = reg.get_sub_tile();
+
+    int xmin = reg_rect.xmin();
+    int ymin = reg_rect.ymin();
+    int xmax = reg_rect.xmax();
+    int ymax = reg_rect.ymax();
+
+    for (int i = xmax; i >= xmin; i--) {
+        for (int j = ymax; j >= ymin; j--) {
+            auto& tile = device_ctx.grid[i][j].type;
+            if (is_sub_tile_compatible(tile, block_type, subtile)) {
+                num_sub_tiles++;
+            }
+        }
+    }
+
+    return num_sub_tiles;
+}
+
+void GridTileLookup::print_type_matrix(vtr::NdMatrix<int, 2>& type_count) {
+    for (int i_col = type_count.dim_size(0) - 1; i_col >= 0; i_col--) {
+        for (int j_row = type_count.dim_size(1) - 1; j_row >= 0; j_row--) {
+            VTR_LOG("%d ", type_count[i_col][j_row]);
+        }
+        VTR_LOG("\n");
+    }
+}