specify available move types explicitly

soheilshahrouz · soheilshahrouz · commit 88fb2e1c7dcf · 2024-04-01T20:54:35.000-04:00
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 indicies are calculated based on the dimensions to access the appropriate elements.
+ * The indices 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.
  */
@@ -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");
     }
@@ -57,7 +57,7 @@ void CheckSetup(const t_packer_opts& PackerOpts,
         if (!Timing.timing_analysis_enabled
             && (DEMAND_ONLY != RouterOpts.base_cost_type && DEMAND_ONLY_NORMALIZED_LENGTH != RouterOpts.base_cost_type)) {
             VPR_FATAL_ERROR(VPR_ERROR_OTHER,
-                            "base_cost_type must be demand_only or demand_only_normailzed_length when timing analysis is disabled.\n");
+                            "base_cost_type must be demand_only or demand_only_normalized_length when timing analysis is disabled.\n");
         }
     }
 
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, Timing feasible Region(TFR), Critical UniformMove}, 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
@@ -550,9 +550,9 @@ enum class e_timing_update_type {
  ****************************************************************************/
 
 /* Values of number of placement available move types */
-#define NUM_PL_MOVE_TYPES 7
-#define NUM_PL_NONTIMING_MOVE_TYPES 3
-#define NUM_PL_1ST_STATE_MOVE_TYPES 4
+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
@@ -1,24 +1,27 @@
 #include "RL_agent_util.h"
 #include "manual_move_generator.h"
 
-void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator, std::unique_ptr<MoveGenerator>& move_generator2, const t_placer_opts& placer_opts, int move_lim) {
-    if (placer_opts.RL_agent_placement == false) {
+void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator,
+                            std::unique_ptr<MoveGenerator>& move_generator2,
+                            const t_placer_opts& placer_opts,
+                            int move_lim) {
+    if (!placer_opts.RL_agent_placement) { // RL agent is disabled
         if (placer_opts.place_algorithm.is_timing_driven()) {
             VTR_LOG("Using static probabilities for choosing each move type\n");
-            VTR_LOG("Probability of Uniform_move : %f \n", placer_opts.place_static_move_prob[0]);
-            VTR_LOG("Probability of Median_move : %f \n", placer_opts.place_static_move_prob[1]);
-            VTR_LOG("Probability of Centroid_move : %f \n", placer_opts.place_static_move_prob[2]);
-            VTR_LOG("Probability of Weighted_centroid_move : %f \n", placer_opts.place_static_move_prob[3]);
-            VTR_LOG("Probability of Weighted_median_move : %f \n", placer_opts.place_static_move_prob[4]);
-            VTR_LOG("Probability of Timing_feasible_region_move : %f \n", placer_opts.place_static_move_prob[5]);
-            VTR_LOG("Probability of Critical_uniform_move : %f \n", placer_opts.place_static_move_prob[6]);
+            VTR_LOG("Probability of Uniform_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::UNIFORM]);
+            VTR_LOG("Probability of Median_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::MEDIAN]);
+            VTR_LOG("Probability of Centroid_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::CENTROID]);
+            VTR_LOG("Probability of Weighted_centroid_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::W_CENTROID]);
+            VTR_LOG("Probability of Weighted_median_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::W_MEDIAN]);
+            VTR_LOG("Probability of Critical_uniform_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::CRIT_UNIFORM]);
+            VTR_LOG("Probability of Timing_feasible_region_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::FEASIBLE_REGION]);
             move_generator = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_move_prob);
             move_generator2 = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_move_prob);
         } else { //Non-timing driven placement
             VTR_LOG("Using static probabilities for choosing each move type\n");
-            VTR_LOG("Probability of Uniform_move : %f \n", placer_opts.place_static_notiming_move_prob[0]);
-            VTR_LOG("Probability of Median_move : %f \n", placer_opts.place_static_notiming_move_prob[1]);
-            VTR_LOG("Probability of Centroid_move : %f \n", placer_opts.place_static_notiming_move_prob[2]);
+            VTR_LOG("Probability of Uniform_move : %f \n", placer_opts.place_static_notiming_move_prob[(int)e_move_type::UNIFORM]);
+            VTR_LOG("Probability of Median_move : %f \n", placer_opts.place_static_notiming_move_prob[(int)e_move_type::MEDIAN]);
+            VTR_LOG("Probability of Centroid_move : %f \n", placer_opts.place_static_notiming_move_prob[(int)e_move_type::CENTROID]);
             move_generator = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_notiming_move_prob);
             move_generator2 = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_notiming_move_prob);
         }
@@ -42,27 +45,35 @@ void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator, std:
          *      only move type.                                                *
          *      This state is activated late in the anneal and in the Quench   */
 
-        int num_1st_state_avail_moves = placer_opts.place_algorithm.is_timing_driven() ? NUM_PL_1ST_STATE_MOVE_TYPES : NUM_PL_NONTIMING_MOVE_TYPES;
-        int num_2nd_state_avail_moves = placer_opts.place_algorithm.is_timing_driven() ? NUM_PL_MOVE_TYPES : NUM_PL_NONTIMING_MOVE_TYPES;
+        std::vector<e_move_type> first_state_avail_moves {e_move_type::UNIFORM, e_move_type::MEDIAN, e_move_type::CENTROID};
+        if (placer_opts.place_algorithm.is_timing_driven()) {
+            first_state_avail_moves.push_back(e_move_type::W_CENTROID);
+        }
+
+        std::vector<e_move_type> second_state_avail_moves {e_move_type::UNIFORM, e_move_type::MEDIAN, e_move_type::CENTROID};
+        if (placer_opts.place_algorithm.is_timing_driven()) {
+            second_state_avail_moves.insert(second_state_avail_moves.end(),
+                                            {e_move_type::W_CENTROID, e_move_type::W_MEDIAN, e_move_type::CRIT_UNIFORM, e_move_type::FEASIBLE_REGION});
+        }
 
         if (placer_opts.place_agent_algorithm == E_GREEDY) {
             std::unique_ptr<EpsilonGreedyAgent> karmed_bandit_agent1, karmed_bandit_agent2;
             //agent's 1st state
             if (placer_opts.place_agent_space == e_agent_space::MOVE_BLOCK_TYPE) {
                 VTR_LOG("Using simple RL 'Epsilon Greedy agent' for choosing move and block types\n");
-                karmed_bandit_agent1 = std::make_unique<EpsilonGreedyAgent>(num_1st_state_avail_moves,
+                karmed_bandit_agent1 = std::make_unique<EpsilonGreedyAgent>(first_state_avail_moves,
                                                                             e_agent_space::MOVE_BLOCK_TYPE,
                                                                             placer_opts.place_agent_epsilon);
             } else {
                 VTR_LOG("Using simple RL 'Epsilon Greedy agent' for choosing move types\n");
-                karmed_bandit_agent1 = std::make_unique<EpsilonGreedyAgent>(num_1st_state_avail_moves,
+                karmed_bandit_agent1 = std::make_unique<EpsilonGreedyAgent>(first_state_avail_moves,
                                                                             e_agent_space::MOVE_TYPE,
                                                                             placer_opts.place_agent_epsilon);
             }
             karmed_bandit_agent1->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generator = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent1);
             //agent's 2nd state
-            karmed_bandit_agent2 = std::make_unique<EpsilonGreedyAgent>(num_2nd_state_avail_moves,
+            karmed_bandit_agent2 = std::make_unique<EpsilonGreedyAgent>(second_state_avail_moves,
                                                                         e_agent_space::MOVE_TYPE,
                                                                         placer_opts.place_agent_epsilon);
             karmed_bandit_agent2->set_step(placer_opts.place_agent_gamma, move_lim);
@@ -72,46 +83,56 @@ void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator, std:
             //agent's 1st state
             if (placer_opts.place_agent_space == e_agent_space::MOVE_BLOCK_TYPE) {
                 VTR_LOG("Using simple RL 'Softmax agent' for choosing move and block types\n");
-                karmed_bandit_agent1 = std::make_unique<SoftmaxAgent>(num_1st_state_avail_moves,
+                karmed_bandit_agent1 = std::make_unique<SoftmaxAgent>(first_state_avail_moves,
                                                                       e_agent_space::MOVE_BLOCK_TYPE);
             } else {
                 VTR_LOG("Using simple RL 'Softmax agent' for choosing move types\n");
-                karmed_bandit_agent1 = std::make_unique<SoftmaxAgent>(num_1st_state_avail_moves,
+                karmed_bandit_agent1 = std::make_unique<SoftmaxAgent>(first_state_avail_moves,
                                                                       e_agent_space::MOVE_TYPE);
             }
             karmed_bandit_agent1->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generator = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent1);
             //agent's 2nd state
-            karmed_bandit_agent2 = std::make_unique<SoftmaxAgent>(num_2nd_state_avail_moves,
+            karmed_bandit_agent2 = std::make_unique<SoftmaxAgent>(second_state_avail_moves,
                                                                   e_agent_space::MOVE_TYPE);
             karmed_bandit_agent2->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generator2 = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent2);
         }
     }
 }
 
-void assign_current_move_generator(std::unique_ptr<MoveGenerator>& move_generator, 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) {
+void assign_current_move_generator(std::unique_ptr<MoveGenerator>& move_generator,
+                                   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) {
     if (in_quench) {
-        if (placer_opts.place_quench_algorithm.is_timing_driven() && placer_opts.place_agent_multistate == true)
+        if (placer_opts.place_quench_algorithm.is_timing_driven() && placer_opts.place_agent_multistate)
             current_move_generator = std::move(move_generator2);
         else
             current_move_generator = std::move(move_generator);
     } else {
-        if (agent_state == EARLY_IN_THE_ANNEAL || placer_opts.place_agent_multistate == false)
+        if (agent_state == EARLY_IN_THE_ANNEAL || !placer_opts.place_agent_multistate)
             current_move_generator = std::move(move_generator);
         else
             current_move_generator = std::move(move_generator2);
     }
 }
 
-void update_move_generator(std::unique_ptr<MoveGenerator>& move_generator, 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) {
+void update_move_generator(std::unique_ptr<MoveGenerator>& move_generator,
+                           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) {
     if (in_quench) {
-        if (placer_opts.place_quench_algorithm.is_timing_driven() && placer_opts.place_agent_multistate == true)
+        if (placer_opts.place_quench_algorithm.is_timing_driven() && placer_opts.place_agent_multistate)
             move_generator2 = std::move(current_move_generator);
         else
             move_generator = std::move(current_move_generator);
     } else {
-        if (agent_state == EARLY_IN_THE_ANNEAL || placer_opts.place_agent_multistate == false)
+        if (agent_state == EARLY_IN_THE_ANNEAL || !placer_opts.place_agent_multistate)
             move_generator = std::move(current_move_generator);
         else
             move_generator2 = std::move(current_move_generator);
diff --git a/vpr/src/place/place.cpp b/vpr/src/place/place.cpp
@@ -936,9 +936,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() * placer_opts.place_static_move_prob.size(), 0);
-    move_type_stat.accepted_moves.resize(device_ctx.logical_block_types.size() * placer_opts.place_static_move_prob.size(), 0);
-    move_type_stat.rejected_moves.resize(device_ctx.logical_block_types.size() * placer_opts.place_static_move_prob.size(), 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 +1725,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 * (placer_opts.place_static_move_prob.size())) + (int)proposed_action.move_type];
+        ++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];
     }
     LOG_MOVE_STATS_PROPOSED(t, blocks_affected);
 
@@ -1876,7 +1876,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 * (placer_opts.place_static_move_prob.size())) + (int)proposed_action.move_type];
+                ++move_type_stat.accepted_moves[(proposed_action.logical_blk_type_index * (int)e_move_type::NUMBER_OF_AUTO_MOVES) + (int)proposed_action.move_type];
             }
             if (noc_opts.noc) {
                 commit_noc_costs();
@@ -1927,7 +1927,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 * (placer_opts.place_static_move_prob.size())) + (int)proposed_action.move_type];
+                ++move_type_stat.rejected_moves[(proposed_action.logical_blk_type_index * (int)e_move_type::NUMBER_OF_AUTO_MOVES) + (int)proposed_action.move_type];
             }
             /* Revert the traffic flow routes within the NoC*/
             if (noc_opts.noc) {
diff --git a/vpr/src/place/simpleRL_move_generator.cpp b/vpr/src/place/simpleRL_move_generator.cpp
diff --git a/vpr/src/place/simpleRL_move_generator.h b/vpr/src/place/simpleRL_move_generator.h

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 indicies are calculated based on the dimensions to access the appropriate elements.`
	`142`	`+ * The indices 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`	`*/`
`@@ -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`	`}`
`@@ -57,7 +57,7 @@ void CheckSetup(const t_packer_opts& PackerOpts,`
`57`	`57`	`if (!Timing.timing_analysis_enabled`
`58`	`58`	`&& (DEMAND_ONLY != RouterOpts.base_cost_type && DEMAND_ONLY_NORMALIZED_LENGTH != RouterOpts.base_cost_type)) {`
`59`	`59`	`VPR_FATAL_ERROR(VPR_ERROR_OTHER,`
`60`		`- "base_cost_type must be demand_only or demand_only_normailzed_length when timing analysis is disabled.\n");`
	`60`	`+ "base_cost_type must be demand_only or demand_only_normalized_length when timing analysis is disabled.\n");`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`