Merge branch 'specify_moves_explicitly' into noc_pack_part

soheilshahrouz · soheilshahrouz · commit 08bad8f72970 · 2024-04-29T12:11:21.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
@@ -288,7 +288,7 @@ class NdMatrixBase {
         data_ = std::make_unique<T[]>(size());
     }
 
-    ///@brief Returns the size of the matrix (number of elements) calucated from the current dimensions
+    ///@brief Returns the size of the matrix (number of elements) calculated from the current dimensions
     size_t calc_size() const {
         ///@brief Size is the product of all dimension sizes
         size_t cnt = dim_size(0);
@@ -310,7 +310,7 @@ class NdMatrixBase {
  * 
  * Examples:
  * 
- *       //A 2-dimensional matrix with indicies [0..4][0..9]
+ *       //A 2-dimensional matrix with indices [0..4][0..9]
  *       NdMatrix<int,2> m1({5,10});
  * 
  *       //Accessing an element
@@ -319,17 +319,17 @@ class NdMatrixBase {
  *       //Setting an element
  *       m1[2][8] = 0;
  * 
- *       //A 3-dimensional matrix with indicies [0..4][0..9][0..19]
+ *       //A 3-dimensional matrix with indices [0..4][0..9][0..19]
  *       NdMatrix<int,3> m2({5,10,20});
  * 
- *       //A 2-dimensional matrix with indicies [0..4][0..9], with all entries
+ *       //A 2-dimensional matrix with indices [0..4][0..9], with all entries
  *       //initialized to 42
  *       NdMatrix<int,2> m3({5,10}, 42);
  * 
  *       //Filling all entries with value 101
  *       m3.fill(101);
  * 
- *       //Resizing an existing matrix (all values reset to default constucted value)
+ *       //Resizing an existing matrix (all values reset to default constructed value)
  *       m3.resize({5,5})
  * 
  *       //Resizing an existing matrix (all elements set to value 88)
diff --git a/vpr/src/base/CheckSetup.cpp b/vpr/src/base/CheckSetup.cpp
@@ -38,7 +38,7 @@ void CheckSetup(const t_packer_opts& PackerOpts,
                         "Timing analysis must be enabled for timing-driven placement.\n");
     }
 
-    if (!PlacerOpts.doPlacement && ("" != PlacerOpts.constraints_file)) {
+    if (!PlacerOpts.doPlacement && (!PlacerOpts.constraints_file.empty())) {
         VPR_FATAL_ERROR(VPR_ERROR_OTHER,
                         "A block location file requires that placement is enabled.\n");
     }
diff --git a/vpr/src/base/SetupGrid.cpp b/vpr/src/base/SetupGrid.cpp
@@ -318,7 +318,7 @@ 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) {
-    //Are the resources satisified?
+    //Are the resources satisfied?
     auto overused_resources = grid_overused_resources(grid, instance_counts);
 
     if (!overused_resources.empty()) {
diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp
@@ -2034,7 +2034,8 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .help(
             "The percentage probabilities of different moves in Simulated Annealing placement."
             "This option is only effective for timing-driven placement."
-            "The numbers listed are interpreted as the percentage probabilities of {uniformMove, MedianMove, CentroidMove, WeightedCentroid, WeightedMedian, Critical UniformMove, Timing feasible Region(TFR)}, in that order.")
+            "The numbers listed are interpreted as the percentage probabilities of {uniformMove, MedianMove, CentroidMove, "
+            "WeightedCentroid, WeightedMedian, Critical UniformMove, Timing feasible Region(TFR)}, in that order.")
         .nargs('+')
         .default_value({"100", "0", "0", "0", "0", "0", "0"})
 
diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h
@@ -89,11 +89,9 @@ enum class ScreenUpdatePriority {
 /* Values large enough to be way out of range for any data, but small enough
  * to allow a small number to be added to them without going out of range. */
 #define HUGE_POSITIVE_FLOAT 1.e30
-#define HUGE_NEGATIVE_FLOAT -1.e30
 
 /* Used to avoid floating-point errors when comparing values close to 0 */
 #define EPSILON 1.e-15
-#define NEGATIVE_EPSILON -1.e-15
 
 #define FIRST_ITER_WIRELENTH_LIMIT 0.85 /* If used wirelength exceeds this value in first iteration of routing, do not route */
 
@@ -110,8 +108,6 @@ constexpr auto INVALID_BLOCK_ID = ClusterBlockId(-2);
  * and maps it to the complex logic blocks found in the architecture
  ******************************************************************************/
 
-#define NO_CLUSTER -1
-#define NEVER_CLUSTER -2
 #define NOT_VALID (-10000) /* Marks gains that aren't valid */
 /* Ensure no gain can ever be this negative! */
 #ifndef UNDEFINED
@@ -553,7 +549,6 @@ enum class e_timing_update_type {
 /* Values of number of placement available move types */
 constexpr int NUM_PL_MOVE_TYPES = 7;
 constexpr int NUM_PL_NONTIMING_MOVE_TYPES = 3;
-constexpr int NUM_PL_1ST_STATE_MOVE_TYPES = 4;
 
 /* Timing data structures end */
 enum sched_type {
diff --git a/vpr/src/place/RL_agent_util.cpp b/vpr/src/place/RL_agent_util.cpp
@@ -119,7 +119,8 @@ void assign_current_move_generator(std::unique_ptr<MoveGenerator>& move_generato
                                    std::unique_ptr<MoveGenerator>& move_generator2,
                                    e_agent_state agent_state,
                                    const t_placer_opts& placer_opts,
-                                   bool in_quench, std::unique_ptr<MoveGenerator>& current_move_generator) {
+                                   bool in_quench,
+                                   std::unique_ptr<MoveGenerator>& current_move_generator) {
     if (in_quench) {
         if (placer_opts.place_quench_algorithm.is_timing_driven() && placer_opts.place_agent_multistate)
             current_move_generator = std::move(move_generator2);
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/move_utils.cpp b/vpr/src/place/move_utils.cpp
@@ -1029,7 +1029,7 @@ void compressed_grid_to_loc(t_logical_block_type_ptr blk_type,
     auto& grid = g_vpr_ctx.device().grid;
     auto to_type = grid.get_physical_type({grid_loc.x, grid_loc.y, grid_loc.layer_num});
 
-    //Each x/y location contains only a single type, so we can pick a random z (capcity) location
+    //Each x/y location contains only a single type, so we can pick a random z (capacity) location
     auto& compatible_sub_tiles = compressed_block_grid.compatible_sub_tile_num(to_type->index);
     int sub_tile = compatible_sub_tiles[vtr::irand((int)compatible_sub_tiles.size() - 1)];
 
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) {
@@ -4352,10 +4351,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(
@@ -4365,11 +4361,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;
@@ -4383,24 +4380,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++;
         }
diff --git a/vpr/src/place/simpleRL_move_generator.cpp b/vpr/src/place/simpleRL_move_generator.cpp
@@ -21,7 +21,7 @@ e_create_move SimpleRLMoveGenerator::propose_move(t_pl_blocks_to_be_moved& block
                                                   const t_placer_opts& placer_opts,
                                                   const PlacerCriticalities* criticalities) {
     proposed_action = karmed_bandit_agent->propose_action();
-    return avail_moves[proposed_action.move_type]->propose_move(blocks_affected, proposed_action, rlim, placer_opts, criticalities);
+    return all_moves[proposed_action.move_type]->propose_move(blocks_affected, proposed_action, rlim, placer_opts, criticalities);
 }
 
 void SimpleRLMoveGenerator::process_outcome(double reward, e_reward_function reward_fun) {
diff --git a/vpr/src/place/simpleRL_move_generator.h b/vpr/src/place/simpleRL_move_generator.h
@@ -84,19 +84,18 @@ class KArmedBanditAgent {
     inline int agent_to_phy_blk_type(int idx);
 
   protected:
-    float exp_alpha_ = -1;                  //Step size for q_ updates (< 0 implies use incremental average)
-    std::vector<e_move_type> available_moves_;
-    size_t num_available_types_;            //Number of block types that exist in the netlist. Agent may not choose the block type.
-    size_t num_available_actions_;          //Total number of available actions
-    bool propose_blk_type_ = false;         //Check if agent should propose both move and block type or only move type
-    std::vector<size_t> num_action_chosen_; //Number of times each arm has been pulled (n)
-    std::vector<float> q_;                  //Estimated value of each arm (Q)
-    size_t last_action_;                    //type of the last action (move type) proposed
+    float exp_alpha_ = -1;                      //Step size for q_ updates (< 0 implies use incremental average)
+    std::vector<e_move_type> available_moves_;  //All available moves from which the agent can choose
+    size_t num_available_types_;                //Number of block types that exist in the netlist. Agent may not choose the block type.
+    size_t num_available_actions_;              //Total number of available actions
+    bool propose_blk_type_ = false;             //Check if agent should propose both move and block type or only move type
+    std::vector<size_t> num_action_chosen_;     //Number of times each arm has been pulled (n)
+    std::vector<float> q_;                      //Estimated value of each arm (Q)
+    size_t last_action_;                        //type of the last action (move type) proposed
     /* Ratios of the average runtime to calculate each move type              */
     /* These ratios are useful for different reward functions                 *
      * The vector is calculated by averaging many runs on different circuits  */
-//    std::vector<double> time_elapsed_
-    const vtr::vector<e_move_type, double> time_elapsed_{1.0, 3.6, 5.4, 2.5, 2.1, 0.8, 2.2, 5.4};
+    const vtr::vector<e_move_type, double> time_elapsed_{1.0, 3.6, 5.4, 2.5, 2.1, 0.8, 2.2};
 
     FILE* agent_info_file_ = nullptr;
 
@@ -164,6 +163,7 @@ class SoftmaxAgent : public KArmedBanditAgent {
     SoftmaxAgent(std::vector<e_move_type> available_moves, e_agent_space agent_space);
     ~SoftmaxAgent() override;
 
+
     t_propose_action propose_action() override; //Returns the type of the next action as well as the block type the agent wishes to perform
 
   private:
@@ -200,8 +200,8 @@ class SoftmaxAgent : public KArmedBanditAgent {
  */
 class SimpleRLMoveGenerator : public MoveGenerator {
   private:
-    vtr::vector<e_move_type, std::unique_ptr<MoveGenerator>> avail_moves; // list of pointers to the available move generators (the different move types)
-    std::unique_ptr<KArmedBanditAgent> karmed_bandit_agent;  // a pointer to the specific agent used (e.g. Softmax)
+    vtr::vector<e_move_type, std::unique_ptr<MoveGenerator>> all_moves; // list of pointers to all move generators (the different move types)
+    std::unique_ptr<KArmedBanditAgent> karmed_bandit_agent;             // a pointer to the specific agent used (e.g. Softmax)
 
   public:
     // constructor using a pointer to the agent used
@@ -232,20 +232,20 @@ class SimpleRLMoveGenerator : public MoveGenerator {
 template<class T, class>
 SimpleRLMoveGenerator::SimpleRLMoveGenerator(std::unique_ptr<T>& agent, float noc_attraction_weight, size_t high_fanout_thresh) {
     if (noc_attraction_weight > 0.0f) {
-        avail_moves.resize((int)e_move_type::NUMBER_OF_AUTO_MOVES);
+        all_moves.resize((int)e_move_type::NUMBER_OF_AUTO_MOVES);
     } else {
-        avail_moves.resize((int)e_move_type::NUMBER_OF_AUTO_MOVES - 1);
+        all_moves.resize((int)e_move_type::NUMBER_OF_AUTO_MOVES - 1);
     }
 
-    avail_moves[e_move_type::UNIFORM] = std::make_unique<UniformMoveGenerator>();
-    avail_moves[e_move_type::MEDIAN] = std::make_unique<MedianMoveGenerator>();
-    avail_moves[e_move_type::CENTROID] = std::make_unique<CentroidMoveGenerator>();
-    avail_moves[e_move_type::W_CENTROID] = std::make_unique<WeightedCentroidMoveGenerator>();
-    avail_moves[e_move_type::W_MEDIAN] = std::make_unique<WeightedMedianMoveGenerator>();
-    avail_moves[e_move_type::CRIT_UNIFORM] = std::make_unique<CriticalUniformMoveGenerator>();
-    avail_moves[e_move_type::FEASIBLE_REGION] = std::make_unique<FeasibleRegionMoveGenerator>();
+    all_moves[e_move_type::UNIFORM] = std::make_unique<UniformMoveGenerator>();
+    all_moves[e_move_type::MEDIAN] = std::make_unique<MedianMoveGenerator>();
+    all_moves[e_move_type::CENTROID] = std::make_unique<CentroidMoveGenerator>();
+    all_moves[e_move_type::W_CENTROID] = std::make_unique<WeightedCentroidMoveGenerator>();
+    all_moves[e_move_type::W_MEDIAN] = std::make_unique<WeightedMedianMoveGenerator>();
+    all_moves[e_move_type::CRIT_UNIFORM] = std::make_unique<CriticalUniformMoveGenerator>();
+    all_moves[e_move_type::FEASIBLE_REGION] = std::make_unique<FeasibleRegionMoveGenerator>();
     if (noc_attraction_weight > 0.0f) {
-        avail_moves[e_move_type::NOC_ATTRACTION_CENTROID] = std::make_unique<CentroidMoveGenerator>(noc_attraction_weight, high_fanout_thresh);
+        all_moves[e_move_type::NOC_ATTRACTION_CENTROID] = std::make_unique<CentroidMoveGenerator>(noc_attraction_weight, high_fanout_thresh);
     }
 
     karmed_bandit_agent = std::move(agent);

Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ class NdMatrixBase {`
`288`	`288`	`data_ = std::make_unique<T[]>(size());`
`289`	`289`	`}`
`290`	`290`
`291`		`- ///@brief Returns the size of the matrix (number of elements) calucated from the current dimensions`
	`291`	`+ ///@brief Returns the size of the matrix (number of elements) calculated from the current dimensions`
`292`	`292`	`size_t calc_size() const {`
`293`	`293`	`///@brief Size is the product of all dimension sizes`
`294`	`294`	`size_t cnt = dim_size(0);`
`@@ -310,7 +310,7 @@ class NdMatrixBase {`
`310`	`310`	`*`
`311`	`311`	`* Examples:`
`312`	`312`	`*`
`313`		`- * //A 2-dimensional matrix with indicies [0..4][0..9]`
	`313`	`+ * //A 2-dimensional matrix with indices [0..4][0..9]`
`314`	`314`	`* NdMatrix<int,2> m1({5,10});`
`315`	`315`	`*`
`316`	`316`	`* //Accessing an element`
`@@ -319,17 +319,17 @@ class NdMatrixBase {`
`319`	`319`	`* //Setting an element`
`320`	`320`	`* m1[2][8] = 0;`
`321`	`321`	`*`
`322`		`- * //A 3-dimensional matrix with indicies [0..4][0..9][0..19]`
	`322`	`+ * //A 3-dimensional matrix with indices [0..4][0..9][0..19]`
`323`	`323`	`* NdMatrix<int,3> m2({5,10,20});`
`324`	`324`	`*`
`325`		`- * //A 2-dimensional matrix with indicies [0..4][0..9], with all entries`
	`325`	`+ * //A 2-dimensional matrix with indices [0..4][0..9], with all entries`
`326`	`326`	`* //initialized to 42`
`327`	`327`	`* NdMatrix<int,2> m3({5,10}, 42);`
`328`	`328`	`*`
`329`	`329`	`* //Filling all entries with value 101`
`330`	`330`	`* m3.fill(101);`
`331`	`331`	`*`
`332`		`- * //Resizing an existing matrix (all values reset to default constucted value)`
	`332`	`+ * //Resizing an existing matrix (all values reset to default constructed value)`
`333`	`333`	`* m3.resize({5,5})`
`334`	`334`	`*`
`335`	`335`	`* //Resizing an existing matrix (all elements set to value 88)`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ void CheckSetup(const t_packer_opts& PackerOpts,`
`38`	`38`	`"Timing analysis must be enabled for timing-driven placement.\n");`
`39`	`39`	`}`
`40`	`40`
`41`		`- if (!PlacerOpts.doPlacement && ("" != PlacerOpts.constraints_file)) {`
	`41`	`+ if (!PlacerOpts.doPlacement && (!PlacerOpts.constraints_file.empty())) {`
`42`	`42`	`VPR_FATAL_ERROR(VPR_ERROR_OTHER,`
`43`	`43`	`"A block location file requires that placement is enabled.\n");`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -318,7 +318,7 @@ static std::vector<t_logical_block_type_ptr> grid_overused_resources(const Devic`
`318`	`318`	`}`
`319`	`319`
`320`	`320`	`static bool grid_satisfies_instance_counts(const DeviceGrid& grid, const std::map<t_logical_block_type_ptr, size_t>& instance_counts, float maximum_utilization) {`
`321`		`- //Are the resources satisified?`
	`321`	`+ //Are the resources satisfied?`
`322`	`322`	`auto overused_resources = grid_overused_resources(grid, instance_counts);`
`323`	`323`
`324`	`324`	`if (!overused_resources.empty()) {`