replace some nested loops with calls to all_locations()

Author: soheilshahrouz

vpr/src/base/blk_loc_registry.cpp

@@ -154,27 +154,21 @@ void BlkLocRegistry::clear_block_type_grid_locs(const std::unordered_set<int>& u
 
     bool clear_all_block_types = false;
 
-    /* check if all types should be cleared
-     * logical_block_types contain empty type, needs to be ignored.
-     * Not having any type in unplaced_blk_types_index means that it is the first iteration, hence all grids needs to be cleared
-     */
+    // check if all types should be cleared
+    // logical_block_types contain empty type, needs to be ignored.
+    // Not having any type in unplaced_blk_types_index means that it is the first iteration, hence all grids needs to be cleared
     if (unplaced_blk_types_index.size() == device_ctx.logical_block_types.size() - 1) {
         clear_all_block_types = true;
     }
 
-    /* We'll use the grid to record where everything goes. Initialize to the grid has no
-     * blocks placed anywhere.
-     */
-    for (int layer_num = 0; layer_num < device_ctx.grid.get_num_layers(); layer_num++) {
-        for (int i = 0; i < (int)device_ctx.grid.width(); i++) {
-            for (int j = 0; j < (int)device_ctx.grid.height(); j++) {
-                const t_physical_tile_type_ptr type = device_ctx.grid.get_physical_type({i, j, layer_num});
-                int itype = type->index;
-                if (clear_all_block_types || unplaced_blk_types_index.count(itype)) {
-                    for (int k = 0; k < device_ctx.physical_tile_types[itype].capacity; k++) {
-                        grid_blocks_.set_block_at_location({i, j, k, layer_num}, ClusterBlockId::INVALID());
-                    }
-                }
+    // We'll use the grid to record where everything goes. Initialize to the grid has no
+    // blocks placed anywhere.
+    for (const t_physical_tile_loc loc : device_ctx.grid.all_locations()) {
+        const t_physical_tile_type_ptr type = device_ctx.grid.get_physical_type(loc);
+        int itype = type->index;
+        if (clear_all_block_types || unplaced_blk_types_index.count(itype)) {
+            for (int k = 0; k < device_ctx.physical_tile_types[itype].capacity; k++) {
+                grid_blocks_.set_block_at_location({loc, k}, ClusterBlockId::INVALID());
             }
         }
     }

vpr/src/base/setup_grid.cpp

@@ -35,7 +35,8 @@ static std::vector<t_logical_block_type_ptr> grid_overused_resources(const Devic
 static bool grid_satisfies_instance_counts(const DeviceGrid& grid, const std::map<t_logical_block_type_ptr, size_t>& instance_counts, float maximum_utilization);
 static DeviceGrid build_device_grid(const t_grid_def& grid_def, size_t width, size_t height, bool warn_out_of_range = true, const std::vector<t_logical_block_type_ptr>& limiting_resources = std::vector<t_logical_block_type_ptr>());
 
-static void CheckGrid(const DeviceGrid& grid);
+///@brief Check grid is valid
+static void check_grid(const DeviceGrid& grid);
 
 static void set_grid_block_type(int priority,
                                 const t_physical_tile_type* type,
@@ -545,7 +546,7 @@ static DeviceGrid build_device_grid(const t_grid_def& grid_def, size_t grid_widt
 
     auto device_grid = DeviceGrid(grid_def.name, grid, limiting_resources);
 
-    CheckGrid(device_grid);
+    check_grid(device_grid);
 
     return device_grid;
 }
@@ -615,8 +616,8 @@ static void set_grid_block_type(int priority,
             priority, type->name.c_str());
     }
 
-    //Mark all the grid tiles 'covered' by this block with the appropriate type
-    //and width/height offsets
+    // Mark all the grid tiles 'covered' by this block with the appropriate type
+    // and width/height offsets
     std::set<TypeLocation> root_blocks_to_rip_up;
     auto& device_ctx = g_vpr_ctx.device();
     for (size_t x = x_root; x < x_root + type->width; ++x) {
@@ -654,9 +655,9 @@ static void set_grid_block_type(int priority,
         }
     }
 
-    //Rip-up any invalidated blocks
+    // Rip-up any invalidated blocks
     for (auto invalidated_root : root_blocks_to_rip_up) {
-        //Mark all the grid locations used by this root block as empty
+        // Mark all the grid locations used by this root block as empty
         for (size_t x = invalidated_root.x; x < invalidated_root.x + invalidated_root.type->width; ++x) {
             int x_offset = x - invalidated_root.x;
             for (size_t y = invalidated_root.y; y < invalidated_root.y + invalidated_root.type->height; ++y) {
@@ -690,65 +691,53 @@ static void set_grid_block_type(int priority,
     }
 }
 
-///@brief Check grid is valid
-static void CheckGrid(const DeviceGrid& grid) {
-    for (int layer_num = 0; layer_num < grid.get_num_layers(); layer_num++) { //Check each die individually
-        for (int i = 0; i < (int)grid.width(); ++i) {
-            for (int j = 0; j < (int)grid.height(); ++j) {
-                const t_physical_tile_loc tile_loc(i, j, layer_num);
-                const auto& type = grid.get_physical_type(tile_loc);
-                int width_offset = grid.get_width_offset(tile_loc);
-                int height_offset = grid.get_height_offset(tile_loc);
-                if (nullptr == type) {
-                    VPR_FATAL_ERROR(VPR_ERROR_OTHER, "Grid Location (%d,%d,%d) has no type.\n", i, j, layer_num);
-                }
+static void check_grid(const DeviceGrid& grid) {
+    for (const t_physical_tile_loc tile_loc : grid.all_locations()) {
+        const t_physical_tile_type_ptr type = grid.get_physical_type(tile_loc);
+        int width_offset = grid.get_width_offset(tile_loc);
+        int height_offset = grid.get_height_offset(tile_loc);
+        if (nullptr == type) {
+            VPR_FATAL_ERROR(VPR_ERROR_OTHER, "Grid Location (%d,%d,%d) has no type.\n", tile_loc.layer_num, tile_loc.x, tile_loc.y);
+        }
 
-                if ((grid.get_width_offset(tile_loc) < 0)
-                    || (grid.get_width_offset(tile_loc) >= type->width)) {
-                    VPR_FATAL_ERROR(VPR_ERROR_OTHER, "Grid Location (%d,%d,%d) has invalid width offset (%d).\n",
-                                    i,
-                                    j,
-                                    layer_num,
-                                    width_offset);
-                }
-                if ((grid.get_height_offset(tile_loc) < 0)
-                    || (grid.get_height_offset(tile_loc) >= type->height)) {
-                    VPR_FATAL_ERROR(VPR_ERROR_OTHER, "Grid Location (%d,%d,%d) has invalid height offset (%d).\n",
-                                    i,
-                                    j,
-                                    layer_num,
-                                    height_offset);
-                }
+        if ((grid.get_width_offset(tile_loc) < 0) || (grid.get_width_offset(tile_loc) >= type->width)) {
+            VPR_FATAL_ERROR(VPR_ERROR_OTHER, "Grid Location (%d,%d,%d) has invalid width offset (%d).\n",
+                            tile_loc.layer_num, tile_loc.x, tile_loc.y,
+                            width_offset);
+            }
+        if ((grid.get_height_offset(tile_loc) < 0) || (grid.get_height_offset(tile_loc) >= type->height)) {
+            VPR_FATAL_ERROR(VPR_ERROR_OTHER, "Grid Location (%d,%d,%d) has invalid height offset (%d).\n",
+                            tile_loc.layer_num, tile_loc.x, tile_loc.y,
+                            height_offset);
+            }
 
-                //Verify that type and width/height offsets are correct (e.g. for dimension > 1 blocks)
-                if (grid.get_width_offset(tile_loc) == 0 && grid.get_height_offset(tile_loc) == 0) {
-                    //From the root block check that all other blocks are correct
-                    for (int x = i; x < i + type->width; ++x) {
-                        int x_offset = x - i;
-                        for (int y = j; y < j + type->height; ++y) {
-                            int y_offset = y - j;
-                            const t_physical_tile_loc tile_loc_offset(x, y, layer_num);
-                            const auto& tile_type = grid.get_physical_type(tile_loc_offset);
-                            int tile_width_offset = grid.get_width_offset(tile_loc_offset);
-                            int tile_height_offset = grid.get_height_offset(tile_loc_offset);
-                            if (tile_type != type) {
-                                VPR_FATAL_ERROR(VPR_ERROR_OTHER,
-                                                "Grid Location (%d,%d,%d) should have type '%s' (based on root location) but has type '%s'\n",
-                                                i, j, layer_num, type->name.c_str(), type->name.c_str());
-                            }
-
-                            if (tile_width_offset != x_offset) {
-                                VPR_FATAL_ERROR(VPR_ERROR_OTHER,
-                                                "Grid Location (%d,%d,%d) of type '%s' should have width offset '%d' (based on root location) but has '%d'\n",
-                                                i, j, layer_num, type->name.c_str(), x_offset, tile_width_offset);
-                            }
-
-                            if (tile_height_offset != y_offset) {
-                                VPR_FATAL_ERROR(VPR_ERROR_OTHER,
-                                                "Grid Location (%d,%d,%d)  of type '%s' should have height offset '%d' (based on root location) but has '%d'\n",
-                                                i, j, layer_num, type->name.c_str(), y_offset, tile_height_offset);
-                            }
-                        }
+        // Verify that type and width/height offsets are correct (e.g. for dimension > 1 blocks)
+        if (grid.get_width_offset(tile_loc) == 0 && grid.get_height_offset(tile_loc) == 0) {
+            // From the root block check that all other blocks are correct
+            for (int x = tile_loc.x; x < tile_loc.x + type->width; ++x) {
+                int x_offset = x - tile_loc.x;
+                for (int y = tile_loc.y; y < tile_loc.y + type->height; ++y) {
+                    int y_offset = y - tile_loc.y;
+                    const t_physical_tile_loc tile_loc_offset(x, y, tile_loc.layer_num);
+                    const auto& tile_type = grid.get_physical_type(tile_loc_offset);
+                    int tile_width_offset = grid.get_width_offset(tile_loc_offset);
+                    int tile_height_offset = grid.get_height_offset(tile_loc_offset);
+                    if (tile_type != type) {
+                        VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                                        "Grid Location (%d,%d,%d) should have type '%s' (based on root location) but has type '%s'\n",
+                                        tile_loc.layer_num, tile_loc.x, tile_loc.y, type->name.c_str(), type->name.c_str());
+                    }
+
+                    if (tile_width_offset != x_offset) {
+                        VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                                        "Grid Location (%d,%d,%d) of type '%s' should have width offset '%d' (based on root location) but has '%d'\n",
+                                        tile_loc.layer_num, tile_loc.x, tile_loc.y, type->name.c_str(), x_offset, tile_width_offset);
+                    }
+
+                    if (tile_height_offset != y_offset) {
+                        VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                                        "Grid Location (%d,%d,%d)  of type '%s' should have height offset '%d' (based on root location) but has '%d'\n",
+                                        tile_loc.layer_num, tile_loc.x, tile_loc.y, type->name.c_str(), y_offset, tile_height_offset);
                     }
                 }
             }

vpr/src/base/stats.cpp

@@ -85,21 +85,18 @@ void routing_stats(const Netlist<>& net_list,
     VTR_LOG("Logic area (in minimum width transistor areas, excludes I/Os and empty grid tiles)...\n");
 
     float area = 0;
-    for (int layer_num = 0; layer_num < device_ctx.grid.get_num_layers(); layer_num++) {
-        for (int i = 0; i < (int)device_ctx.grid.width(); i++) {
-            for (int j = 0; j < (int)device_ctx.grid.height(); j++) {
-                auto type = device_ctx.grid.get_physical_type({i, j, layer_num});
-                int width_offset = device_ctx.grid.get_width_offset({i, j, layer_num});
-                int height_offset = device_ctx.grid.get_height_offset({i, j, layer_num});
-                if (width_offset == 0 && height_offset == 0 && !type->is_io() && !type->is_empty()) {
-                    if (type->area == UNDEFINED) {
-                        area += grid_logic_tile_area * type->width * type->height;
-                    } else {
-                        area += type->area;
-                    }
-                }
+
+    for (const t_physical_tile_loc tile_loc : device_ctx.grid.all_locations()) {
+        t_physical_tile_type_ptr type = device_ctx.grid.get_physical_type(tile_loc);
+        int width_offset = device_ctx.grid.get_width_offset(tile_loc);
+        int height_offset = device_ctx.grid.get_height_offset(tile_loc);
+        if (width_offset == 0 && height_offset == 0 && !type->is_io() && !type->is_empty()) {
+            if (type->area == UNDEFINED) {
+                area += grid_logic_tile_area * type->width * type->height;
+            } else {
+                area += type->area;
             }
-        }
+    }
     }
     /* Todo: need to add pitch of routing to blocks with height > 3 */
     VTR_LOG("\tTotal logic block area (Warning, need to add pitch of routing to blocks with height > 3): %g\n", area);
@@ -540,22 +537,19 @@ int count_netlist_clocks() {
 }
 
 float calculate_device_utilization(const DeviceGrid& grid, const std::map<t_logical_block_type_ptr, size_t>& instance_counts) {
-    //Record the resources of the grid
+    // Record the resources of the grid
     std::map<t_physical_tile_type_ptr, size_t> grid_resources;
-    for (int layer_num = 0; layer_num < grid.get_num_layers(); ++layer_num) {
-        for (int x = 0; x < (int)grid.width(); ++x) {
-            for (int y = 0; y < (int)grid.height(); ++y) {
-                int width_offset = grid.get_width_offset({x, y, layer_num});
-                int height_offset = grid.get_height_offset({x, y, layer_num});
-                if (width_offset == 0 && height_offset == 0) {
-                    const auto& type = grid.get_physical_type({x, y, layer_num});
-                    ++grid_resources[type];
-                }
-            }
+
+    for (const t_physical_tile_loc tile_loc : grid.all_locations()) {
+        int width_offset = grid.get_width_offset(tile_loc);
+        int height_offset = grid.get_height_offset(tile_loc);
+        if (width_offset == 0 && height_offset == 0) {
+            const t_physical_tile_type_ptr type = grid.get_physical_type(tile_loc);
+            ++grid_resources[type];
         }
     }
 
-    //Determine the area of grid in tile units
+    // Determine the area of grid in tile units
     float grid_area = 0.;
     for (auto& kv : grid_resources) {
         t_physical_tile_type_ptr type = kv.first;
@@ -566,7 +560,7 @@ float calculate_device_utilization(const DeviceGrid& grid, const std::map<t_logi
         grid_area += type_area * count;
     }
 
-    //Determine the area of instances in tile units
+    // Determine the area of instances in tile units
     float instance_area = 0.;
     for (auto& kv : instance_counts) {
         if (is_empty_type(kv.first)) {

vpr/src/place/delay_model/compute_delta_delays_utils.cpp

@@ -395,8 +395,8 @@ static bool verify_delta_delays(const vtr::NdMatrix<float, 4>& delta_delays) {
     const auto& device_ctx = g_vpr_ctx.device();
     const auto& grid = device_ctx.grid;
 
-    for (int from_layer_num = 0; from_layer_num < grid.get_num_layers(); ++from_layer_num) {
-        for (int to_layer_num = 0; to_layer_num < grid.get_num_layers(); ++to_layer_num) {
+    for (size_t from_layer_num = 0; from_layer_num < grid.get_num_layers(); ++from_layer_num) {
+        for (size_t to_layer_num = 0; to_layer_num < grid.get_num_layers(); ++to_layer_num) {
             for (size_t x = 0; x < grid.width(); ++x) {
                 for (size_t y = 0; y < grid.height(); ++y) {
                     float delta_delay = delta_delays[from_layer_num][to_layer_num][x][y];
@@ -838,7 +838,7 @@ bool find_direct_connect_sample_locations(const t_direct_inf* direct,
     bool found = false;
     int found_layer_num = -1;
     //TODO: Function *FOR NOW* assumes that from/to blocks are at same die and have a same layer nums
-    for (int layer_num = 0; layer_num < grid.get_num_layers() && !found; ++layer_num) {
+    for (int layer_num = 0; layer_num < (int)grid.get_num_layers() && !found; ++layer_num) {
         for (int x = 0; x < (int)grid.width() && !found; ++x) {
             to_x = x + direct->x_offset;
             if (to_x < 0 || to_x >= (int)grid.width()) continue;

vpr/src/place/net_cost_handler.cpp

@@ -494,7 +494,7 @@ void NetCostHandler::get_non_updatable_cube_bb_(ClusterNetId net_id, bool use_ts
     bb_coord_new.ymax = source_pin_loc.y;
     bb_coord_new.layer_max = source_pin_loc.layer_num;
 
-    for (int layer_num = 0; layer_num < device_ctx.grid.get_num_layers(); layer_num++) {
+    for (size_t layer_num = 0; layer_num < device_ctx.grid.get_num_layers(); layer_num++) {
         num_sink_pin_layer[layer_num] = 0;
     }
 
@@ -1096,9 +1096,11 @@ static void update_bb_pin_sink_count(const t_physical_tile_loc& pin_old_loc,
                                      vtr::NdMatrixProxy<int, 1> bb_pin_sink_count_new,
                                      bool is_output_pin) {
     VTR_ASSERT_SAFE(curr_layer_pin_sink_count[pin_old_loc.layer_num] > 0 || is_output_pin);
-    for (int layer_num = 0; layer_num < g_vpr_ctx.device().grid.get_num_layers(); layer_num++) {
+
+    for (size_t layer_num = 0; layer_num < g_vpr_ctx.device().grid.get_num_layers(); layer_num++) {
         bb_pin_sink_count_new[layer_num] = curr_layer_pin_sink_count[layer_num];
     }
+
     if (!is_output_pin) {
         bb_pin_sink_count_new[pin_old_loc.layer_num] -= 1;
         bb_pin_sink_count_new[pin_new_loc.layer_num] += 1;
@@ -1197,7 +1199,7 @@ void NetCostHandler::get_bb_from_scratch_(ClusterNetId net_id, bool use_ts) {
     int ymax_edge = 1;
     int layer_max_edge = 1;
 
-    for (int layer_num = 0; layer_num < grid.get_num_layers(); layer_num++) {
+    for (size_t layer_num = 0; layer_num < grid.get_num_layers(); layer_num++) {
         num_sink_pin_layer[layer_num] = 0;
     }
 
@@ -1549,7 +1551,7 @@ void NetCostHandler::update_move_nets() {
 
         set_ts_bb_coord_(net_id);
 
-        for (int layer_num = 0; layer_num < g_vpr_ctx.device().grid.get_num_layers(); layer_num++) {
+        for (size_t layer_num = 0; layer_num < g_vpr_ctx.device().grid.get_num_layers(); layer_num++) {
             num_sink_pin_layer_[size_t(net_id)][layer_num] = ts_layer_sink_pin_count_[size_t(net_id)][layer_num];
         }