Merge branch 'fix_no_delay_model' into master+wip

Author: litghost

vpr/src/place/place.cpp

@@ -327,19 +327,19 @@ static e_swap_result try_swap(float t,
                               t_placer_costs* costs,
                               t_placer_prev_inverse_costs* prev_inverse_costs,
                               float rlim,
-                              const PlaceDelayModel& delay_model,
+                              const PlaceDelayModel* delay_model,
                               float rlim_escape_fraction,
                               enum e_place_algorithm place_algorithm,
                               float timing_tradeoff);
 
 static ClusterBlockId pick_from_block();
 
 static void check_place(const t_placer_costs& costs,
-                        const PlaceDelayModel& delay_model,
+                        const PlaceDelayModel* delay_model,
                         enum e_place_algorithm place_algorithm);
 
 static int check_placement_costs(const t_placer_costs& costs,
-                                 const PlaceDelayModel& delay_model,
+                                 const PlaceDelayModel* delay_model,
                                  enum e_place_algorithm place_algorithm);
 static int check_placement_consistency();
 static int check_block_placement_consistency();
@@ -350,7 +350,7 @@ static float starting_t(t_placer_costs* costs,
                         t_annealing_sched annealing_sched,
                         int max_moves,
                         float rlim,
-                        const PlaceDelayModel& delay_model,
+                        const PlaceDelayModel* delay_model,
                         const t_placer_opts& placer_opts);
 
 static void update_t(float* t, float rlim, float success_rat, t_annealing_sched annealing_sched);
@@ -365,15 +365,15 @@ static double get_std_dev(int n, double sum_x_squared, double av_x);
 
 static double recompute_bb_cost();
 
-static float comp_td_point_to_point_delay(const PlaceDelayModel& delay_model, ClusterNetId net_id, int ipin);
+static float comp_td_point_to_point_delay(const PlaceDelayModel* delay_model, ClusterNetId net_id, int ipin);
 
-static void comp_td_point_to_point_delays(const PlaceDelayModel& delay_model);
+static void comp_td_point_to_point_delays(const PlaceDelayModel* delay_model);
 
 static void update_td_cost();
 
 static bool driven_by_moved_block(const ClusterNetId net);
 
-static void comp_td_costs(const PlaceDelayModel& delay_model, double* timing_cost);
+static void comp_td_costs(const PlaceDelayModel* delay_model, double* timing_cost);
 
 static e_swap_result assess_swap(double delta_c, double t);
 
@@ -383,12 +383,12 @@ static void get_non_updateable_bb(ClusterNetId net_id, t_bb* bb_coord_new);
 
 static void update_bb(ClusterNetId net_id, t_bb* bb_coord_new, t_bb* bb_edge_new, int xold, int yold, int xnew, int ynew);
 
-static int find_affected_nets_and_update_costs(e_place_algorithm place_algorithm, const PlaceDelayModel& delay_model, double& bb_delta_c, double& timing_delta_c);
+static int find_affected_nets_and_update_costs(e_place_algorithm place_algorithm, const PlaceDelayModel* delay_model, double& bb_delta_c, double& timing_delta_c);
 
 static void record_affected_net(const ClusterNetId net, int& num_affected_nets);
 
 static void update_net_bb(const ClusterNetId net, int iblk, const ClusterBlockId blk, const ClusterPinId blk_pin);
-static void update_td_delta_costs(const PlaceDelayModel& delay_model, const ClusterNetId net, const ClusterPinId pin, double& delta_timing_cost);
+static void update_td_delta_costs(const PlaceDelayModel* delay_model, const ClusterNetId net, const ClusterPinId pin, double& delta_timing_cost);
 
 static double get_net_cost(ClusterNetId net_id, t_bb* bb_ptr);
 
@@ -405,7 +405,7 @@ static void outer_loop_recompute_criticalities(const t_placer_opts& placer_opts,
                                                float crit_exponent,
                                                int* outer_crit_iter_count,
                                                const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
-                                               const PlaceDelayModel& delay_model,
+                                               const PlaceDelayModel* delay_model,
                                                SetupTimingInfo& timing_info);
 
 static void placement_inner_loop(float t,
@@ -419,10 +419,10 @@ static void placement_inner_loop(float t,
                                  t_placer_prev_inverse_costs* prev_inverse_costs,
                                  int* moves_since_cost_recompute,
                                  const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
-                                 const PlaceDelayModel& delay_model,
+                                 const PlaceDelayModel* delay_model,
                                  SetupTimingInfo& timing_info);
 
-static void recompute_costs_from_scratch(const t_placer_opts& placer_opts, const PlaceDelayModel& delay_model, t_placer_costs* costs);
+static void recompute_costs_from_scratch(const t_placer_opts& placer_opts, const PlaceDelayModel* delay_model, t_placer_costs* costs);
 
 static void calc_placer_stats(t_placer_statistics& stats, float& success_rat, double& std_dev, const t_placer_costs& costs, const int move_lim);
 
@@ -485,7 +485,8 @@ void try_place(const t_placer_opts& placer_opts,
 
     std::shared_ptr<SetupTimingInfo> timing_info;
     std::shared_ptr<PlacementDelayCalculator> placement_delay_calc;
-    std::unique_ptr<PlaceDelayModel> place_delay_model;
+    std::unique_ptr<PlaceDelayModel> place_delay_model_holder;
+    const PlaceDelayModel* place_delay_model = nullptr;
 
     /* Allocated here because it goes into timing critical code where each memory allocation is expensive */
     IntraLbPbPinLookup pb_gpin_lookup(device_ctx.block_types, device_ctx.num_block_types);
@@ -499,7 +500,8 @@ void try_place(const t_placer_opts& placer_opts,
     if (placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE
         || placer_opts.enable_timing_computations) {
         /*do this before the initial placement to avoid messing up the initial placement */
-        place_delay_model = alloc_lookups_and_criticalities(chan_width_dist, placer_opts, router_opts, det_routing_arch, segment_inf, directs, num_directs);
+        place_delay_model_holder = alloc_lookups_and_criticalities(chan_width_dist, placer_opts, router_opts, det_routing_arch, segment_inf, directs, num_directs);
+        place_delay_model = place_delay_model_holder.get();
 
         if (isEchoFileEnabled(E_ECHO_PLACEMENT_DELTA_DELAY_MODEL)) {
             place_delay_model->dump_echo(getEchoFileName(E_ECHO_PLACEMENT_DELTA_DELAY_MODEL));
@@ -532,7 +534,7 @@ void try_place(const t_placer_opts& placer_opts,
         VTR_LOG("\n");
 
         //Update the point-to-point delays from the initial placement
-        comp_td_point_to_point_delays(*place_delay_model);
+        comp_td_point_to_point_delays(place_delay_model);
 
         /*
          * Initialize timing analysis
@@ -560,7 +562,7 @@ void try_place(const t_placer_opts& placer_opts,
         }
 
         /*now we can properly compute costs  */
-        comp_td_costs(*place_delay_model, &costs.timing_cost); /*also updates values in point_to_point_delay */
+        comp_td_costs(place_delay_model, &costs.timing_cost); /*also updates values in point_to_point_delay */
 
         outer_crit_iter_count = 1;
 
@@ -581,7 +583,7 @@ void try_place(const t_placer_opts& placer_opts,
     }
 
     //Sanity check that initial placement is legal
-    check_place(costs, *place_delay_model, placer_opts.place_algorithm);
+    check_place(costs, place_delay_model, placer_opts.place_algorithm);
 
     //Initial pacement statistics
     VTR_LOG("Initial placement cost: %g bb_cost: %g td_cost: %g\n",
@@ -638,7 +640,7 @@ void try_place(const t_placer_opts& placer_opts,
 
     t = starting_t(&costs, &prev_inverse_costs,
                    annealing_sched, move_lim, rlim,
-                   *place_delay_model,
+                   place_delay_model,
                    placer_opts);
 
     tot_iter = 0;
@@ -655,7 +657,7 @@ void try_place(const t_placer_opts& placer_opts,
                                            crit_exponent,
                                            &outer_crit_iter_count,
                                            netlist_pin_lookup,
-                                           *place_delay_model,
+                                           place_delay_model,
                                            *timing_info);
 
         placement_inner_loop(t, rlim, placer_opts,
@@ -664,7 +666,7 @@ void try_place(const t_placer_opts& placer_opts,
                              &prev_inverse_costs,
                              &moves_since_cost_recompute,
                              netlist_pin_lookup,
-                             *place_delay_model,
+                             place_delay_model,
                              *timing_info);
 
         tot_iter += move_lim;
@@ -709,7 +711,7 @@ void try_place(const t_placer_opts& placer_opts,
                                        crit_exponent,
                                        &outer_crit_iter_count,
                                        netlist_pin_lookup,
-                                       *place_delay_model,
+                                       place_delay_model,
                                        *timing_info);
 
     t = 0; /* freeze out */
@@ -722,7 +724,7 @@ void try_place(const t_placer_opts& placer_opts,
                          &prev_inverse_costs,
                          &moves_since_cost_recompute,
                          netlist_pin_lookup,
-                         *place_delay_model,
+                         place_delay_model,
                          *timing_info);
 
     tot_iter += move_lim;
@@ -747,7 +749,7 @@ void try_place(const t_placer_opts& placer_opts,
     }
 #endif
 
-    check_place(costs, *place_delay_model, placer_opts.place_algorithm);
+    check_place(costs, place_delay_model, placer_opts.place_algorithm);
 
     //Some stats
     VTR_LOG("\n");
@@ -761,7 +763,7 @@ void try_place(const t_placer_opts& placer_opts,
             for (size_t ipin = 1; ipin < cluster_ctx.clb_nlist.net_pins(net_id).size(); ipin++)
                 set_timing_place_crit(net_id, ipin, 0); /*dummy crit values */
         }
-        comp_td_costs(*place_delay_model, &costs.timing_cost); /*computes point_to_point_delay */
+        comp_td_costs(place_delay_model, &costs.timing_cost); /*computes point_to_point_delay */
     }
 
     if (placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE
@@ -838,7 +840,7 @@ static void outer_loop_recompute_criticalities(const t_placer_opts& placer_opts,
                                                float crit_exponent,
                                                int* outer_crit_iter_count,
                                                const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
-                                               const PlaceDelayModel& delay_model,
+                                               const PlaceDelayModel* delay_model,
                                                SetupTimingInfo& timing_info) {
     if (placer_opts.place_algorithm != PATH_TIMING_DRIVEN_PLACE)
         return;
@@ -882,7 +884,7 @@ static void placement_inner_loop(float t,
                                  t_placer_prev_inverse_costs* prev_inverse_costs,
                                  int* moves_since_cost_recompute,
                                  const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
-                                 const PlaceDelayModel& delay_model,
+                                 const PlaceDelayModel* delay_model,
                                  SetupTimingInfo& timing_info) {
     int inner_crit_iter_count, inner_iter;
 
@@ -960,7 +962,7 @@ static void placement_inner_loop(float t,
     /* Inner loop ends */
 }
 
-static void recompute_costs_from_scratch(const t_placer_opts& placer_opts, const PlaceDelayModel& delay_model, t_placer_costs* costs) {
+static void recompute_costs_from_scratch(const t_placer_opts& placer_opts, const PlaceDelayModel* delay_model, t_placer_costs* costs) {
     double new_bb_cost = recompute_bb_cost();
     if (fabs(new_bb_cost - costs->bb_cost) > costs->bb_cost * ERROR_TOL) {
         std::string msg = vtr::string_fmt("in recompute_costs_from_scratch: new_bb_cost = %g, old bb_cost = %g\n",
@@ -1083,7 +1085,7 @@ static float starting_t(t_placer_costs* costs,
                         t_annealing_sched annealing_sched,
                         int max_moves,
                         float rlim,
-                        const PlaceDelayModel& delay_model,
+                        const PlaceDelayModel* delay_model,
                         const t_placer_opts& placer_opts) {
     /* Finds the starting temperature (hot condition).              */
 
@@ -1699,7 +1701,7 @@ static e_swap_result try_swap(float t,
                               t_placer_costs* costs,
                               t_placer_prev_inverse_costs* prev_inverse_costs,
                               float rlim,
-                              const PlaceDelayModel& delay_model,
+                              const PlaceDelayModel* delay_model,
                               float rlim_escape_fraction,
                               enum e_place_algorithm place_algorithm,
                               float timing_tradeoff) {
@@ -1875,7 +1877,7 @@ static ClusterBlockId pick_from_block() {
 //and updates their bounding box.
 //
 //Returns the number of affected nets.
-static int find_affected_nets_and_update_costs(e_place_algorithm place_algorithm, const PlaceDelayModel& delay_model, double& bb_delta_c, double& timing_delta_c) {
+static int find_affected_nets_and_update_costs(e_place_algorithm place_algorithm, const PlaceDelayModel* delay_model, double& bb_delta_c, double& timing_delta_c) {
     VTR_ASSERT_SAFE(bb_delta_c == 0.);
     VTR_ASSERT_SAFE(timing_delta_c == 0.);
     auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -1962,7 +1964,7 @@ static void update_net_bb(const ClusterNetId net, int iblk, const ClusterBlockId
     }
 }
 
-static void update_td_delta_costs(const PlaceDelayModel& delay_model, const ClusterNetId net, const ClusterPinId pin, double& delta_timing_cost) {
+static void update_td_delta_costs(const PlaceDelayModel* delay_model, const ClusterNetId net, const ClusterPinId pin, double& delta_timing_cost) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     if (cluster_ctx.clb_nlist.pin_type(pin) == PinType::DRIVER) {
@@ -2168,7 +2170,7 @@ static double recompute_bb_cost() {
 }
 
 /*returns the delay of one point to point connection */
-static float comp_td_point_to_point_delay(const PlaceDelayModel& delay_model, ClusterNetId net_id, int ipin) {
+static float comp_td_point_to_point_delay(const PlaceDelayModel* delay_model, ClusterNetId net_id, int ipin) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& place_ctx = g_vpr_ctx.placement();
 
@@ -2198,12 +2200,12 @@ static float comp_td_point_to_point_delay(const PlaceDelayModel& delay_model, Cl
          *       In particular this aproach does not accurately capture the effect of fast
          *       carry-chain connections.
          */
-        delay_source_to_sink = delay_model.delay(source_x,
-                                                 source_y,
-                                                 source_block_ipin,
-                                                 sink_x,
-                                                 sink_y,
-                                                 sink_block_ipin);
+        delay_source_to_sink = delay_model->delay(source_x,
+                                                  source_y,
+                                                  source_block_ipin,
+                                                  sink_x,
+                                                  sink_y,
+                                                  sink_block_ipin);
         if (delay_source_to_sink < 0) {
             VPR_ERROR(VPR_ERROR_PLACE,
                       "in comp_td_point_to_point_delay: Bad delay_source_to_sink value %g from %s (at %d,%d) to %s (at %d,%d)\n"
@@ -2220,7 +2222,7 @@ static float comp_td_point_to_point_delay(const PlaceDelayModel& delay_model, Cl
 }
 
 //Recompute all point to point delays, updating point_to_point_delay
-static void comp_td_point_to_point_delays(const PlaceDelayModel& delay_model) {
+static void comp_td_point_to_point_delays(const PlaceDelayModel* delay_model) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     for (auto net_id : cluster_ctx.clb_nlist.nets()) {
@@ -2283,7 +2285,7 @@ static bool driven_by_moved_block(const ClusterNetId net) {
     return false;
 }
 
-static void comp_td_costs(const PlaceDelayModel& delay_model, double* timing_cost) {
+static void comp_td_costs(const PlaceDelayModel* delay_model, double* timing_cost) {
     /* Computes the cost (from scratch) from the delays and criticalities    *
      * of all point to point connections, we define the timing cost of       *
      * each connection as criticality*delay.                                 */
@@ -3461,7 +3463,7 @@ static void alloc_and_load_for_fast_cost_update(float place_cost_exp) {
 }
 
 static void check_place(const t_placer_costs& costs,
-                        const PlaceDelayModel& delay_model,
+                        const PlaceDelayModel* delay_model,
                         enum e_place_algorithm place_algorithm) {
     /* Checks that the placement has not confused our data structures. *
      * i.e. the clb and block structures agree about the locations of  *
@@ -3487,7 +3489,7 @@ static void check_place(const t_placer_costs& costs,
 }
 
 static int check_placement_costs(const t_placer_costs& costs,
-                                 const PlaceDelayModel& delay_model,
+                                 const PlaceDelayModel* delay_model,
                                  enum e_place_algorithm place_algorithm) {
     int error = 0;
     double bb_cost_check;