replace std::vector with NdMatrix in MoveTypeStat

soheilshahrouz · soheilshahrouz · commit 8e28113a5c18 · 2024-04-02T15:51:31.000-04:00
diff --git a/libs/libarchfpga/src/device_grid.cpp b/libs/libarchfpga/src/device_grid.cpp
@@ -1,14 +1,16 @@
 #include "device_grid.h"
 
+#include <utility>
+
 DeviceGrid::DeviceGrid(std::string grid_name, vtr::NdMatrix<t_grid_tile, 3> grid)
-    : name_(grid_name)
-    , grid_(grid) {
+    : name_(std::move(grid_name))
+    , grid_(std::move(grid)) {
     count_instances();
 }
 
 DeviceGrid::DeviceGrid(std::string grid_name, vtr::NdMatrix<t_grid_tile, 3> grid, std::vector<t_logical_block_type_ptr> limiting_res)
-    : DeviceGrid(grid_name, grid) {
-    limiting_resources_ = limiting_res;
+    : DeviceGrid(std::move(grid_name), std::move(grid)) {
+    limiting_resources_ = std::move(limiting_res);
 }
 
 size_t DeviceGrid::num_instances(t_physical_tile_type_ptr type, int layer_num) const {
diff --git a/libs/libvtrutil/src/vtr_ndmatrix.h b/libs/libvtrutil/src/vtr_ndmatrix.h
@@ -139,7 +139,7 @@ class NdMatrixProxy<T, 1> {
  * This should improve memory usage (no extra pointers to store for each dimension),
  * and cache locality (less indirection via pointers, predictable strides).
  *
- * The indices are calculated based on the dimensions to access the appropriate elements.
+ * The indicies are calculated based on the dimensions to access the appropriate elements.
  * Since the indexing calculations are visible to the compiler at compile time they can be
  * optimized to be efficient.
  */
diff --git a/vpr/src/base/SetupGrid.cpp b/vpr/src/base/SetupGrid.cpp
@@ -31,8 +31,8 @@ using vtr::t_formula_data;
 
 static DeviceGrid auto_size_device_grid(const std::vector<t_grid_def>& grid_layouts, const std::map<t_logical_block_type_ptr, size_t>& minimum_instance_counts, float maximum_device_utilization);
 static std::vector<t_logical_block_type_ptr> grid_overused_resources(const DeviceGrid& grid, std::map<t_logical_block_type_ptr, size_t> instance_counts);
-static bool grid_satisfies_instance_counts(const DeviceGrid& grid, 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, std::vector<t_logical_block_type_ptr> limiting_resources = std::vector<t_logical_block_type_ptr>());
+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);
 
@@ -316,8 +316,8 @@ static std::vector<t_logical_block_type_ptr> grid_overused_resources(const Devic
     return overused_resources;
 }
 
-static bool grid_satisfies_instance_counts(const DeviceGrid& grid, std::map<t_logical_block_type_ptr, size_t> instance_counts, float maximum_utilization) {
-    //Are the resources satisified?
+static bool grid_satisfies_instance_counts(const DeviceGrid& grid, const std::map<t_logical_block_type_ptr, size_t>& instance_counts, float maximum_utilization) {
+    //Are the resources satisfied?
     auto overused_resources = grid_overused_resources(grid, instance_counts);
 
     if (!overused_resources.empty()) {
@@ -335,7 +335,7 @@ static bool grid_satisfies_instance_counts(const DeviceGrid& grid, std::map<t_lo
 }
 
 ///@brief Build the specified device grid
-static DeviceGrid build_device_grid(const t_grid_def& grid_def, size_t grid_width, size_t grid_height, bool warn_out_of_range, const std::vector<t_logical_block_type_ptr> limiting_resources) {
+static DeviceGrid build_device_grid(const t_grid_def& grid_def, size_t grid_width, size_t grid_height, bool warn_out_of_range, const std::vector<t_logical_block_type_ptr>& limiting_resources) {
     if (grid_def.grid_type == GridDefType::FIXED) {
         if (grid_def.width != int(grid_width) || grid_def.height != int(grid_height)) {
             VPR_FATAL_ERROR(VPR_ERROR_OTHER,
@@ -754,7 +754,7 @@ static void CheckGrid(const DeviceGrid& grid) {
     }
 }
 
-float calculate_device_utilization(const DeviceGrid& grid, std::map<t_logical_block_type_ptr, size_t> instance_counts) {
+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
     std::map<t_physical_tile_type_ptr, size_t> grid_resources;
     for (int layer_num = 0; layer_num < grid.get_num_layers(); ++layer_num) {
diff --git a/vpr/src/base/SetupGrid.h b/vpr/src/base/SetupGrid.h
@@ -27,7 +27,7 @@ DeviceGrid create_device_grid(std::string layout_name, const std::vector<t_grid_
  * Calculate the device utilization (i.e. fraction of used grid tiles)
  * foor the specified grid and resource requirements
  */
-float calculate_device_utilization(const DeviceGrid& grid, std::map<t_logical_block_type_ptr, size_t> instance_counts);
+float calculate_device_utilization(const DeviceGrid& grid, const std::map<t_logical_block_type_ptr, size_t>& instance_counts);
 
 /**
  * @brief Returns the effective size of the device
diff --git a/vpr/src/place/move_generator.h b/vpr/src/place/move_generator.h
@@ -23,15 +23,15 @@ struct MoveOutcomeStats {
 /**
  * @brief A Struct to hold statistics about the different move types
  *
- * blk_type_moves: the block type index of each proposed move (e.g. [0..NUM_PL_MOVE_TYPES * (agent_available_types.size()-1)])
- * accepted_moves: the number of accepted moves of each move and block type (e.g. [0..NUM_PL_MOVE_TYPES * (agent_available_types.size()-1)] )
- * rejected_moves: the number of rejected moves of each move and block type (e.g. [0..NUM_PL_MOVE_TYPES * (agent_available_types.size()-1)] )
+ * blk_type_moves: the block type index of each proposed move (e.g. [0..NUM_PL_MOVE_TYPES][agent_available_types.size()-1)])
+ * accepted_moves: the number of accepted moves of each move and block type (e.g. [0..NUM_PL_MOVE_TYPES][agent_available_types.size()-1)] )
+ * rejected_moves: the number of rejected moves of each move and block type (e.g. [0..NUM_PL_MOVE_TYPES][agent_available_types.size()-1)] )
  *
  */
 struct MoveTypeStat {
-    std::vector<int> blk_type_moves;
-    std::vector<int> accepted_moves;
-    std::vector<int> rejected_moves;
+    vtr::NdMatrix<int, 2> blk_type_moves;
+    vtr::NdMatrix<int, 2> accepted_moves;
+    vtr::NdMatrix<int, 2> rejected_moves;
 };
 
 /**
diff --git a/vpr/src/place/place.cpp b/vpr/src/place/place.cpp
@@ -543,8 +543,7 @@ static void print_resources_utilization();
 
 static void print_placement_swaps_stats(const t_annealing_state& state);
 
-static void print_placement_move_types_stats(
-    const MoveTypeStat& move_type_stat);
+static void print_placement_move_types_stats(const MoveTypeStat& move_type_stat);
 
 /*****************************************************************************/
 void try_place(const Netlist<>& net_list,
@@ -936,9 +935,9 @@ void try_place(const Netlist<>& net_list,
 
     //allocate move type statistics vectors
     MoveTypeStat move_type_stat;
-    move_type_stat.blk_type_moves.resize(device_ctx.logical_block_types.size() * (int)e_move_type::NUMBER_OF_AUTO_MOVES, 0);
-    move_type_stat.accepted_moves.resize(device_ctx.logical_block_types.size() * (int)e_move_type::NUMBER_OF_AUTO_MOVES, 0);
-    move_type_stat.rejected_moves.resize(device_ctx.logical_block_types.size() * (int)e_move_type::NUMBER_OF_AUTO_MOVES, 0);
+    move_type_stat.blk_type_moves.resize({device_ctx.logical_block_types.size(), (int)e_move_type::NUMBER_OF_AUTO_MOVES}, 0);
+    move_type_stat.accepted_moves.resize({device_ctx.logical_block_types.size(), (int)e_move_type::NUMBER_OF_AUTO_MOVES}, 0);
+    move_type_stat.rejected_moves.resize({device_ctx.logical_block_types.size(), (int)e_move_type::NUMBER_OF_AUTO_MOVES}, 0);
 
     /* Get the first range limiter */
     first_rlim = (float)max(device_ctx.grid.width() - 1,
@@ -1725,7 +1724,7 @@ static e_move_result try_swap(const t_annealing_state* state,
     }
 
     if (proposed_action.logical_blk_type_index != -1) { //if the agent proposed the block type, then collect the block type stat
-        ++move_type_stat.blk_type_moves[(proposed_action.logical_blk_type_index * (int)e_move_type::NUMBER_OF_AUTO_MOVES) + (int)proposed_action.move_type];
+        ++move_type_stat.blk_type_moves[proposed_action.logical_blk_type_index][(int)proposed_action.move_type];
     }
     LOG_MOVE_STATS_PROPOSED(t, blocks_affected);
 
@@ -1876,7 +1875,7 @@ static e_move_result try_swap(const t_annealing_state* state,
             commit_move_blocks(blocks_affected);
 
             if (proposed_action.logical_blk_type_index != -1) { //if the agent proposed the block type, then collect the block type stat
-                ++move_type_stat.accepted_moves[(proposed_action.logical_blk_type_index * (int)e_move_type::NUMBER_OF_AUTO_MOVES) + (int)proposed_action.move_type];
+                ++move_type_stat.accepted_moves[proposed_action.logical_blk_type_index][(int)proposed_action.move_type];
             }
             if (noc_opts.noc) {
                 commit_noc_costs();
@@ -1927,7 +1926,7 @@ static e_move_result try_swap(const t_annealing_state* state,
             }
 
             if (proposed_action.logical_blk_type_index != -1) { //if the agent proposed the block type, then collect the block type stat
-                ++move_type_stat.rejected_moves[(proposed_action.logical_blk_type_index * (int)e_move_type::NUMBER_OF_AUTO_MOVES) + (int)proposed_action.move_type];
+                ++move_type_stat.rejected_moves[proposed_action.logical_blk_type_index][(int)proposed_action.move_type];
             }
             /* Revert the traffic flow routes within the NoC*/
             if (noc_opts.noc) {
@@ -4350,10 +4349,7 @@ static void print_placement_swaps_stats(const t_annealing_state& state) {
             num_swap_aborted, 100 * abort_rate);
 }
 
-static void print_placement_move_types_stats(
-    const MoveTypeStat& move_type_stat) {
-    float moves, accepted, rejected, aborted;
-
+static void print_placement_move_types_stats(const MoveTypeStat& move_type_stat) {
     VTR_LOG("\n\nPlacement perturbation distribution by block and move type: \n");
 
     VTR_LOG(
@@ -4363,11 +4359,12 @@ static void print_placement_move_types_stats(
     VTR_LOG(
         "------------------ ----------------- ---------------- ---------------- --------------- ------------ \n");
 
-    float total_moves = 0;
-    for (int blk_type_move : move_type_stat.blk_type_moves) {
-        total_moves += blk_type_move;
+    int total_moves = 0;
+    for (size_t i = 0; i < move_type_stat.blk_type_moves.size(); ++i) {
+        total_moves +=  move_type_stat.blk_type_moves.get(i);
     }
 
+
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();
     int count = 0;
@@ -4381,24 +4378,23 @@ static void print_placement_move_types_stats(
         }
 
         count = 0;
-
         for (int imove = 0; imove < num_of_avail_moves; imove++) {
             const auto& move_name = move_type_to_string(e_move_type(imove));
-            moves = move_type_stat.blk_type_moves[itype.index * num_of_avail_moves + imove];
+            int moves = move_type_stat.blk_type_moves[itype.index][imove];
             if (moves != 0) {
-                accepted = move_type_stat.accepted_moves[itype.index * num_of_avail_moves + imove];
-                rejected = move_type_stat.rejected_moves[itype.index * num_of_avail_moves + imove];
-                aborted = moves - (accepted + rejected);
+                int accepted = move_type_stat.accepted_moves[itype.index][imove];
+                int rejected = move_type_stat.rejected_moves[itype.index][imove];
+                int aborted = moves - (accepted + rejected);
                 if (count == 0) {
                     VTR_LOG("%-18.20s", itype.name);
                 } else {
                     VTR_LOG("                  ");
                 }
                 VTR_LOG(
                     " %-22.20s %-16.2f %-15.2f %-14.2f %-13.2f\n",
-                    move_name.c_str(), 100 * moves / total_moves,
-                    100 * accepted / moves, 100 * rejected / moves,
-                    100 * aborted / moves);
+                    move_name.c_str(), 100.0f * (float)moves / (float)total_moves,
+                    100.0f * (float)accepted / (float)moves, 100.0f * (float)rejected / (float)moves,
+                    100.0f * (float)aborted / (float)moves);
             }
             count++;
         }

Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ class NdMatrixProxy<T, 1> {`
`139`	`139`	`* This should improve memory usage (no extra pointers to store for each dimension),`
`140`	`140`	`* and cache locality (less indirection via pointers, predictable strides).`
`141`	`141`	`*`
`142`		`- * The indices are calculated based on the dimensions to access the appropriate elements.`
	`142`	`+ * The indicies are calculated based on the dimensions to access the appropriate elements.`
`143`	`143`	`* Since the indexing calculations are visible to the compiler at compile time they can be`
`144`	`144`	`* optimized to be efficient.`
`145`	`145`	`*/`