[vpr][placer] creating ts struct and hiding 2d 3d control flow in class

Author: Yulang Luo

vpr/src/place/net_cost_handler.cpp

@@ -1,5 +1,8 @@
 #include "net_cost_handler.h"
+#include "clustered_netlist_fwd.h"
 #include "globals.h"
+#include "physical_types.h"
+#include "physical_types_util.h"
 #include "placer_globals.h"
 #include "move_utils.h"
 #include "place_timing_update.h"
@@ -91,14 +94,33 @@ static struct PLNetCost pl_net_cost;
  * layer_ts_bb_coord_new are used.
  */
 
-/* [0...cluster_ctx.clb_nlist.nets().size()-1] -> 3D bounding box*/
-static vtr::vector<ClusterNetId, t_bb> ts_bb_coord_new, ts_bb_edge_new;
-/* [0...cluster_ctx.clb_nlist.nets().size()-1][0...num_layers-1] -> 2D bonding box on a layer*/
-static vtr::vector<ClusterNetId, std::vector<t_2D_bb>> layer_ts_bb_edge_new, layer_ts_bb_coord_new;
-/* [0...cluster_ctx.clb_nlist.nets().size()-1][0...num_layers-1] -> number of sink pins on a layer*/
-static vtr::Matrix<int> ts_layer_sink_pin_count;
-/* [0...num_afftected_nets] -> net_id of the affected nets */
-static std::vector<ClusterNetId> ts_nets_to_update;
+struct TSInfo{
+    /* [0...cluster_ctx.clb_nlist.nets().size()-1] -> 3D bounding box*/
+    vtr::vector<ClusterNetId, t_bb> ts_bb_coord_new, ts_bb_edge_new;
+    /* [0...cluster_ctx.clb_nlist.nets().size()-1][0...num_layers-1] -> 2D bonding box on a layer*/
+    vtr::vector<ClusterNetId, std::vector<t_2D_bb>> layer_ts_bb_edge_new, layer_ts_bb_coord_new;
+    /* [0...cluster_ctx.clb_nlist.nets().size()-1][0...num_layers-1] -> number of sink pins on a layer*/
+    vtr::Matrix<int> ts_layer_sink_pin_count;
+    /* [0...num_afftected_nets] -> net_id of the affected nets */
+    std::vector<ClusterNetId> ts_nets_to_update;
+};
+static struct TSInfo ts_info;
+
+/**
+ * @brief This class is used to hide control flows needed to distinguish 2d and 3d placement
+ */
+class BB2D3DControlFlow {
+    bool cube_bb = false; 
+public: 
+    void init(size_t num_nets, bool cube_bb);
+    void get_non_updatable_bb(const ClusterNetId& net);
+    bool is_driver(const t_physical_tile_type_ptr& blk_type, const ClusterPinId& blk_pin);
+    void update_bb(ClusterNetId net_id, t_physical_tile_loc pin_old_loc, t_physical_tile_loc pin_new_loc, bool is_driver); 
+    double get_net_cost(const ClusterNetId& net_id);
+    void set_ts_bb_coord(const ClusterNetId& net_id);
+    void set_ts_edge(const ClusterNetId& net_id);
+};
+static BB2D3DControlFlow bb_2d_3d_control_flow;
 
 /**
  * @param net
@@ -209,26 +231,6 @@ static void get_non_updatable_bb(ClusterNetId net_id,
                                   t_bb& bb_coord_new,
                                   vtr::NdMatrixProxy<int, 1> num_sink_pin_layer);
 
-
-/**
- * @brief Update the bounding box (per-layer) of the net connected to blk_pin. The old and new locations of the pin are
- * stored in pl_moved_block. The updated bounding box will be stored in ts data structures.
- * @details Finds the bounding box of a net and stores its coordinates in the bb_coord_new 
- * data structure.  This routine should only be called for small nets, since it does not 
- * determine enough information for the bounding box to be updated incrementally later.                
- * Currently assumes channels on both sides of the CLBs forming the edges of the bounding box 
- * can be used.  Essentially, I am assuming the pins always lie on the outside of the 
- * bounding box.            
- * @param net ID of the net for which the bounding box is requested
- * @param blk ID of the moving block
- * @param blk_pin ID of the pin connected to the net
- * @param pl_moved_block Placement info about
- */
-static void update_net_layer_bb(const ClusterNetId& net,
-                                const ClusterBlockId& blk,
-                                const ClusterPinId& blk_pin,
-                                const t_pl_moved_block& pl_moved_block);
-
 /**
  * @brief Calculate the per-layer bounding box of "net_id" from scratch (based on the block locations stored in place_ctx) and
  * store them in bb_coord_new
@@ -451,7 +453,88 @@ static double wirelength_crossing_count(size_t fanout);
 static void set_bb_delta_cost(const int num_affected_nets, double& bb_delta_c);
 
 /******************************* End of Function definitions ************************************/
+// Initialize the ts vectors
+void BB2D3DControlFlow::init(size_t num_nets, bool cube_bb_in) {
+    const int num_layers = g_vpr_ctx.device().grid.get_num_layers();
 
+    cube_bb = cube_bb_in;
+    if (cube_bb) {
+        ts_info.ts_bb_edge_new.resize(num_nets, t_bb());
+        ts_info.ts_bb_coord_new.resize(num_nets, t_bb());
+    } else {
+        VTR_ASSERT_SAFE(!cube_bb);
+        ts_info.layer_ts_bb_edge_new.resize(num_nets, std::vector<t_2D_bb>(num_layers, t_2D_bb()));
+        ts_info.layer_ts_bb_coord_new.resize(num_nets, std::vector<t_2D_bb>(num_layers, t_2D_bb()));
+    }
+
+    /*This initialize the whole matrix to OPEN which is an invalid value*/
+    ts_info.ts_layer_sink_pin_count.resize({num_nets, size_t(num_layers)}, OPEN);
+
+    ts_info.ts_nets_to_update.resize(num_nets, ClusterNetId::INVALID());
+}
+
+void BB2D3DControlFlow::get_non_updatable_bb(const ClusterNetId& net) {
+    if(cube_bb)
+        ::get_non_updatable_bb(net,
+                               ts_info.ts_bb_coord_new[net],
+                               ts_info.ts_layer_sink_pin_count[size_t(net)]);
+    else
+        ::get_non_updatable_layer_bb(net,
+                                   ts_info.layer_ts_bb_coord_new[net],
+                                   ts_info.ts_layer_sink_pin_count[size_t(net)]);
+}
+
+bool BB2D3DControlFlow::is_driver(const t_physical_tile_type_ptr& blk_type, const ClusterPinId& blk_pin) {
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+    if(cube_bb)
+        return cluster_ctx.clb_nlist.pin_type(blk_pin) == PinType::DRIVER;
+    else
+        return get_pin_type_from_pin_physical_num(blk_type, tile_pin_index(blk_pin)) == e_pin_type::DRIVER;
+}
+
+void BB2D3DControlFlow::update_bb(ClusterNetId net_id, t_physical_tile_loc pin_old_loc, t_physical_tile_loc pin_new_loc, bool is_driver) {
+    if (cube_bb)
+        ::update_bb(net_id,
+                  ts_info.ts_bb_edge_new[net_id],
+                  ts_info.ts_bb_coord_new[net_id],
+                  ts_info.ts_layer_sink_pin_count[size_t(net_id)],
+                  pin_old_loc,
+                  pin_new_loc,
+                  is_driver);
+    else
+        ::update_layer_bb(net_id,
+                  ts_info.layer_ts_bb_edge_new[net_id],
+                  ts_info.layer_ts_bb_coord_new[net_id],
+                  ts_info.ts_layer_sink_pin_count[size_t(net_id)],
+                  pin_old_loc,
+                  pin_new_loc,
+                  is_driver);
+}
+
+double BB2D3DControlFlow::get_net_cost(const ClusterNetId& net_id) {
+    if(cube_bb)
+        return ::get_net_cost(net_id, ts_info.ts_bb_coord_new[net_id]);
+    else
+        return ::get_net_layer_bb_wire_cost(net_id, ts_info.layer_ts_bb_coord_new[net_id], ts_info.ts_layer_sink_pin_count[size_t(net_id)]);
+}
+
+void BB2D3DControlFlow::set_ts_bb_coord(const ClusterNetId& net_id) {
+    auto& place_move_ctx = g_placer_ctx.mutable_move();
+    if (cube_bb) {
+        place_move_ctx.bb_coords[net_id] = ts_info.ts_bb_coord_new[net_id];
+    } else {
+        place_move_ctx.layer_bb_coords[net_id] = ts_info.layer_ts_bb_coord_new[net_id];
+    }
+}
+
+void BB2D3DControlFlow::set_ts_edge(const ClusterNetId& net_id) {
+    auto& place_move_ctx = g_placer_ctx.mutable_move();
+    if (cube_bb) {
+        place_move_ctx.bb_num_on_edges[net_id] = ts_info.ts_bb_edge_new[net_id];
+    } else {
+        place_move_ctx.layer_bb_num_on_edges[net_id] = ts_info.layer_ts_bb_edge_new[net_id];
+    }
+}
 //Returns true if 'net' is driven by one of the blocks in 'blocks_affected'
 static bool driven_by_moved_block(const ClusterNetId net,
                                   const int num_blocks,
@@ -481,70 +564,26 @@ static void update_net_bb(const ClusterNetId& net,
         //For small nets brute-force bounding box update is faster
 
         if (pl_net_cost.bb_update_status[net] == NetUpdateState::NOT_UPDATED_YET) { //Only once per-net
-            get_non_updatable_bb(net,
-                                 ts_bb_coord_new[net],
-                                 ts_layer_sink_pin_count[size_t(net)]);
+            bb_2d_3d_control_flow.get_non_updatable_bb(net);
         }
     } else {
         //For large nets, update bounding box incrementally
         int iblk_pin = tile_pin_index(blk_pin);
-        bool src_pin = cluster_ctx.clb_nlist.pin_type(blk_pin) == PinType::DRIVER;
 
         t_physical_tile_type_ptr blk_type = physical_tile_type(blk);
         int pin_width_offset = blk_type->pin_width_offset[iblk_pin];
         int pin_height_offset = blk_type->pin_height_offset[iblk_pin];
+        bool is_driver = bb_2d_3d_control_flow.is_driver(blk_type, blk_pin);
 
         //Incremental bounding box update
-        update_bb(net,
-                  ts_bb_edge_new[net],
-                  ts_bb_coord_new[net],
-                  ts_layer_sink_pin_count[size_t(net)],
-                  {pl_moved_block.old_loc.x + pin_width_offset,
-                  pl_moved_block.old_loc.y + pin_height_offset,
-                  pl_moved_block.old_loc.layer},
-                  {pl_moved_block.new_loc.x + pin_width_offset,
-                  pl_moved_block.new_loc.y + pin_height_offset,
-                  pl_moved_block.new_loc.layer},
-                  src_pin);
-    }
-}
-
-static void update_net_layer_bb(const ClusterNetId& net,
-                                const ClusterBlockId& blk,
-                                const ClusterPinId& blk_pin,
-                                const t_pl_moved_block& pl_moved_block) {
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-
-    if (cluster_ctx.clb_nlist.net_sinks(net).size() < SMALL_NET) {
-        //For small nets brute-force bounding box update is faster
-
-        if (pl_net_cost.bb_update_status[net] == NetUpdateState::NOT_UPDATED_YET) { //Only once per-net
-            get_non_updatable_layer_bb(net,
-                                       layer_ts_bb_coord_new[net],
-                                       ts_layer_sink_pin_count[size_t(net)]);
-        }
-    } else {
-        //For large nets, update bounding box incrementally
-        int iblk_pin = tile_pin_index(blk_pin);
-
-        t_physical_tile_type_ptr blk_type = physical_tile_type(blk);
-        int pin_width_offset = blk_type->pin_width_offset[iblk_pin];
-        int pin_height_offset = blk_type->pin_height_offset[iblk_pin];
-
-        auto pin_dir = get_pin_type_from_pin_physical_num(blk_type, iblk_pin);
-
-        //Incremental bounding box update
-        update_layer_bb(net,
-                        layer_ts_bb_edge_new[net],
-                        layer_ts_bb_coord_new[net],
-                        ts_layer_sink_pin_count[size_t(net)],
-                        {pl_moved_block.old_loc.x + pin_width_offset,
-                         pl_moved_block.old_loc.y + pin_height_offset,
-                         pl_moved_block.old_loc.layer},
-                        {pl_moved_block.new_loc.x + pin_width_offset,
-                         pl_moved_block.new_loc.y + pin_height_offset,
-                         pl_moved_block.new_loc.layer},
-                        pin_dir == e_pin_type::DRIVER);
+        bb_2d_3d_control_flow.update_bb(net,
+                                        {pl_moved_block.old_loc.x + pin_width_offset,
+                                        pl_moved_block.old_loc.y + pin_height_offset,
+                                        pl_moved_block.old_loc.layer},
+                                        {pl_moved_block.new_loc.x + pin_width_offset,
+                                        pl_moved_block.new_loc.y + pin_height_offset,
+                                        pl_moved_block.new_loc.layer},
+                                        is_driver);
     }
 }
 
@@ -656,7 +695,7 @@ static void record_affected_net(const ClusterNetId net,
     /* Record effected nets. */
     if (pl_net_cost.proposed_net_cost[net] < 0.) {
         /* Net not marked yet. */
-        ts_nets_to_update[num_affected_nets] = net;
+        ts_info.ts_nets_to_update[num_affected_nets] = net;
         num_affected_nets++;
 
         /* Flag to say we've marked this net. */
@@ -688,14 +727,8 @@ static void update_pl_net_cost_on_pin_move(const t_place_algorithm& place_algori
     /* Record effected nets */
     record_affected_net(net_id, num_affected_nets);
 
-    const auto& cube_bb = g_vpr_ctx.placement().cube_bb;
-
     /* Update the net bounding boxes. */
-    if (cube_bb) {
-        update_net_bb(net_id, blk_id, pin_id, moving_blk_inf);
-    } else {
-        update_net_layer_bb(net_id, blk_id, pin_id, moving_blk_inf);
-    }
+    update_net_bb(net_id, blk_id, pin_id, moving_blk_inf);
 
     if (place_algorithm.is_timing_driven()) {
         /* Determine the change in connection delay and timing cost. */
@@ -1862,17 +1895,9 @@ static double wirelength_crossing_count(size_t fanout) {
 static void set_bb_delta_cost(const int num_affected_nets, double& bb_delta_c) {
     for (int inet_affected = 0; inet_affected < num_affected_nets;
          inet_affected++) {
-        ClusterNetId net_id = ts_nets_to_update[inet_affected];
-        const auto& cube_bb = g_vpr_ctx.placement().cube_bb;
-
-        if (cube_bb) {
-            pl_net_cost.proposed_net_cost[net_id] = get_net_cost(net_id,
-                                                     ts_bb_coord_new[net_id]);
-        } else {
-            pl_net_cost.proposed_net_cost[net_id] = get_net_layer_bb_wire_cost(net_id,
-                                                           layer_ts_bb_coord_new[net_id],
-                                                           ts_layer_sink_pin_count[size_t(net_id)]);
-        }
+        ClusterNetId net_id = ts_info.ts_nets_to_update[inet_affected];
+
+        pl_net_cost.proposed_net_cost[net_id] = bb_2d_3d_control_flow.get_net_cost(net_id);
 
         bb_delta_c += pl_net_cost.proposed_net_cost[net_id] - pl_net_cost.net_cost[net_id];
     }
@@ -2004,32 +2029,23 @@ double comp_layer_bb_cost(e_cost_methods method) {
     return cost;
 }
 
-void update_move_nets(int num_nets_affected,
-                      const bool cube_bb) {
+void update_move_nets(int num_nets_affected) {
     /* update net cost functions and reset flags. */
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& place_move_ctx = g_placer_ctx.mutable_move();
 
     for (int inet_affected = 0; inet_affected < num_nets_affected;
          inet_affected++) {
-        ClusterNetId net_id = ts_nets_to_update[inet_affected];
+        ClusterNetId net_id = ts_info.ts_nets_to_update[inet_affected];
 
-        if (cube_bb) {
-            place_move_ctx.bb_coords[net_id] = ts_bb_coord_new[net_id];
-        } else {
-            place_move_ctx.layer_bb_coords[net_id] = layer_ts_bb_coord_new[net_id];
-        }
+        bb_2d_3d_control_flow.set_ts_bb_coord(net_id);
 
         for (int layer_num = 0; layer_num < g_vpr_ctx.device().grid.get_num_layers(); layer_num++) {
-            place_move_ctx.num_sink_pin_layer[size_t(net_id)][layer_num] = ts_layer_sink_pin_count[size_t(net_id)][layer_num];
+            place_move_ctx.num_sink_pin_layer[size_t(net_id)][layer_num] = ts_info.ts_layer_sink_pin_count[size_t(net_id)][layer_num];
         }
 
         if (cluster_ctx.clb_nlist.net_sinks(net_id).size() >= SMALL_NET) {
-            if (cube_bb) {
-                place_move_ctx.bb_num_on_edges[net_id] = ts_bb_edge_new[net_id];
-            } else {
-                place_move_ctx.layer_bb_num_on_edges[net_id] = layer_ts_bb_edge_new[net_id];
-            }
+            bb_2d_3d_control_flow.set_ts_edge(net_id);
         }
 
         pl_net_cost.net_cost[net_id] = pl_net_cost.proposed_net_cost[net_id];
@@ -2044,7 +2060,7 @@ void reset_move_nets(int num_nets_affected) {
     /* Reset the net cost function flags first. */
     for (int inet_affected = 0; inet_affected < num_nets_affected;
          inet_affected++) {
-        ClusterNetId net_id = ts_nets_to_update[inet_affected];
+        ClusterNetId net_id = ts_info.ts_nets_to_update[inet_affected];
         pl_net_cost.proposed_net_cost[net_id] = -1;
         pl_net_cost.bb_update_status[net_id] = NetUpdateState::NOT_UPDATED_YET;
     }
@@ -2235,28 +2251,14 @@ void free_place_move_structs() {
 }
 
 void init_try_swap_net_cost_structs(size_t num_nets, bool cube_bb) {
-    const int num_layers = g_vpr_ctx.device().grid.get_num_layers();
-
-    if (cube_bb) {
-        ts_bb_edge_new.resize(num_nets, t_bb());
-        ts_bb_coord_new.resize(num_nets, t_bb());
-    } else {
-        VTR_ASSERT_SAFE(!cube_bb);
-        layer_ts_bb_edge_new.resize(num_nets, std::vector<t_2D_bb>(num_layers, t_2D_bb()));
-        layer_ts_bb_coord_new.resize(num_nets, std::vector<t_2D_bb>(num_layers, t_2D_bb()));
-    }
-
-    /*This initialize the whole matrix to OPEN which is an invalid value*/
-    ts_layer_sink_pin_count.resize({num_nets, size_t(num_layers)}, OPEN);
-
-    ts_nets_to_update.resize(num_nets, ClusterNetId::INVALID());
+    bb_2d_3d_control_flow.init(num_nets, cube_bb);
 }
 
 void free_try_swap_net_cost_structs() {
-    vtr::release_memory(ts_bb_edge_new);
-    vtr::release_memory(ts_bb_coord_new);
-    vtr::release_memory(layer_ts_bb_edge_new);
-    vtr::release_memory(layer_ts_bb_coord_new);
-    ts_layer_sink_pin_count.clear();
-    vtr::release_memory(ts_nets_to_update);
+    vtr::release_memory(ts_info.ts_bb_edge_new);
+    vtr::release_memory(ts_info.ts_bb_coord_new);
+    vtr::release_memory(ts_info.layer_ts_bb_edge_new);
+    vtr::release_memory(ts_info.layer_ts_bb_coord_new);
+    ts_info.ts_layer_sink_pin_count.clear();
+    vtr::release_memory(ts_info.ts_nets_to_update);
 }

vpr/src/place/net_cost_handler.h

@@ -83,10 +83,8 @@ double comp_layer_bb_cost(e_cost_methods method);
 /**
  * @brief update net cost data structures (in placer context and net_cost in .cpp file) and reset flags (proposed_net_cost and bb_updated_before).
  * @param num_nets_affected The number of nets affected by the move. It is used to determine the index up to which elements in ts_nets_to_update are valid.
- * @param cube_bb True if we should use the 3D bounding box (cube_bb), false otherwise.
  */
-void update_move_nets(int num_nets_affected,
-                      const bool cube_bb);
+void update_move_nets(int num_nets_affected);
 
 /**
  * @brief Reset the net cost function flags (proposed_net_cost and bb_updated_before)

vpr/src/place/place.cpp

@@ -1481,8 +1481,7 @@ static e_move_result try_swap(const t_annealing_state* state,
             }
 
             /* Update net cost functions and reset flags. */
-            update_move_nets(num_nets_affected,
-                             g_vpr_ctx.placement().cube_bb);
+            update_move_nets(num_nets_affected);
 
             /* Update clb data structures since we kept the move. */
             commit_move_blocks(blocks_affected);