remove backing up pb to revert move and rebuild cluster placement stats

Author: MohamedElgammal

vpr/src/pack/re_cluster.cpp

@@ -4,35 +4,23 @@
 #include "cluster_placement.h"
 #include "cluster_router.h"
 
-
 bool move_mol_to_new_cluster(t_pack_molecule* molecule,
                              t_clustering_data& clustering_data,
                              bool during_packing) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
     auto& device_ctx = g_vpr_ctx.device();
-    auto& atom_ctx = g_vpr_ctx.mutable_atom();
 
     bool is_removed, is_created;
-    ClusterBlockId old_clb;
+    ClusterBlockId old_clb = atom_to_cluster(molecule->atom_block_ids[molecule->root]);
+    ;
     int molecule_size = get_array_size_of_molecule(molecule);
 
-    //Backup the original pb of the molecule before the move
-    std::vector<t_pb*> mol_pb_backup;
-    for (int i_atom = 0; i_atom < molecule_size; i_atom++) {
-        if (molecule->atom_block_ids[i_atom]) {
-            t_pb* atom_pb_backup = new t_pb;
-            atom_pb_backup->pb_deep_copy(atom_ctx.lookup.atom_pb(molecule->atom_block_ids[i_atom]));
-            mol_pb_backup.push_back(atom_pb_backup);
-        }
-    }
-
     PartitionRegion temp_cluster_pr;
     t_lb_router_data* old_router_data = nullptr;
     t_lb_router_data* router_data = nullptr;
 
     //Check that there is a place for a new cluster of the same type
-    old_clb = atom_to_cluster(molecule->atom_block_ids[molecule->root]);
     t_logical_block_type_ptr block_type = cluster_ctx.clb_nlist.block_type(old_clb);
     int block_mode = cluster_ctx.clb_nlist.block_pb(old_clb)->mode;
 
@@ -48,7 +36,7 @@ bool move_mol_to_new_cluster(t_pack_molecule* molecule,
     }
 
     //remove the molecule from its current cluster and check the cluster legality after
-    is_removed = remove_mol_from_cluster(molecule, molecule_size, old_clb, old_router_data);
+    is_removed = remove_mol_from_cluster(molecule, molecule_size, old_clb, old_router_data, clustering_data, during_packing);
 
     if (!is_removed) {
         VTR_LOG("Atom: %zu move failed. Can't remove it from the old cluster\n", molecule->atom_block_ids[molecule->root]);
@@ -70,31 +58,22 @@ bool move_mol_to_new_cluster(t_pack_molecule* molecule,
 
     //Commit or revert the move
     if (is_created) {
-        commit_mol_move(old_clb, new_clb, mol_pb_backup, old_router_data, clustering_data, during_packing, true);
+        commit_mol_move(old_clb, new_clb, during_packing, true);
         VTR_LOG("Atom:%zu is moved to a new cluster\n", molecule->atom_block_ids[molecule->root]);
     } else {
-        int atom_idx = 0;
-        for (int i_atom = 0; i_atom < molecule_size; i_atom++) {
-            if (molecule->atom_block_ids[i_atom]) {
-                atom_ctx.lookup.set_atom_clb(molecule->atom_block_ids[i_atom], old_clb);
-                atom_ctx.lookup.set_atom_pb(molecule->atom_block_ids[i_atom], mol_pb_backup[atom_idx]);
-                atom_idx++;
-            }
-        }
+        revert_mol_move(old_clb, molecule, old_router_data, during_packing, clustering_data);
         VTR_LOG("Atom:%zu move failed. Can't start a new cluster of the same type and mode\n", molecule->atom_block_ids[molecule->root]);
     }
 
+    free_router_data(old_router_data);
+    old_router_data = nullptr;
+
     //If the move is done after packing not during it, some fixes need to be done on the
     //clustered netlist
     if (is_created && !during_packing) {
         fix_clustered_netlist(molecule, molecule_size, old_clb, new_clb);
     }
 
-    for (auto atom_pb_backup : mol_pb_backup) {
-        cleanup_pb(atom_pb_backup);
-        delete atom_pb_backup;
-    }
-
     return (is_created);
 }
 
@@ -104,7 +83,6 @@ bool move_mol_to_existing_cluster(t_pack_molecule* molecule,
                                   t_clustering_data& clustering_data) {
     //define required contexts
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& atom_ctx = g_vpr_ctx.mutable_atom();
 
     //define local variables
     bool is_removed, is_added;
@@ -128,56 +106,39 @@ bool move_mol_to_existing_cluster(t_pack_molecule* molecule,
         return false;
     }
 
-    //Backup the original pb of the atom before the move
-    std::vector<t_pb*> mol_pb_backup;
-    for (int i_atom = 0; i_atom < molecule_size; i_atom++) {
-        if (molecule->atom_block_ids[i_atom]) {
-            t_pb* atom_pb_backup = new t_pb;
-            atom_pb_backup->pb_deep_copy(atom_ctx.lookup.atom_pb(molecule->atom_block_ids[i_atom]));
-            mol_pb_backup.push_back(atom_pb_backup);
-        }
-    }
-
     //remove the molecule from its current cluster and check the cluster legality
-    is_removed = remove_mol_from_cluster(molecule, molecule_size, old_clb, old_router_data);
+    is_removed = remove_mol_from_cluster(molecule, molecule_size, old_clb, old_router_data, clustering_data, during_packing);
     if (!is_removed) {
         VTR_LOG("Atom: %zu move failed. Can't remove it from the old cluster\n", root_atom_id);
         return false;
     }
 
+    rebuild_cluster_placemet_stats(new_clb, new_clb_atoms, cluster_ctx.clb_nlist.block_type(new_clb)->index, cluster_ctx.clb_nlist.block_pb(new_clb)->mode);
     //Add the atom to the new cluster
     is_added = pack_mol_in_existing_cluster(molecule, new_clb, new_clb_atoms, during_packing, clustering_data);
 
     //Commit or revert the move
     if (is_added) {
-        commit_mol_move(old_clb, new_clb, mol_pb_backup, old_router_data, clustering_data, during_packing, false);
+        commit_mol_move(old_clb, new_clb, during_packing, false);
         VTR_LOG("Atom:%zu is moved to a new cluster\n", molecule->atom_block_ids[molecule->root]);
     } else {
-        int atom_idx = 0;
-        for (int i_atom = 0; i_atom < molecule_size; i_atom++) {
-            if (molecule->atom_block_ids[i_atom]) {
-                atom_ctx.lookup.set_atom_clb(molecule->atom_block_ids[i_atom], old_clb);
-                atom_ctx.lookup.set_atom_pb(molecule->atom_block_ids[i_atom], mol_pb_backup[atom_idx]);
-                atom_idx++;
-            }
-        }
+        revert_mol_move(old_clb, molecule, old_router_data, during_packing, clustering_data);
         VTR_LOG("Atom:%zu move failed. Can't start a new cluster of the same type and mode\n", molecule->atom_block_ids[molecule->root]);
     }
 
+    free_router_data(old_router_data);
+    old_router_data = nullptr;
+
     //If the move is done after packing not during it, some fixes need to be done on the
     //clustered netlist
     if (is_added && !during_packing) {
         fix_clustered_netlist(molecule, molecule_size, old_clb, new_clb);
     }
 
-    for (auto atom_pb_backup : mol_pb_backup) {
-        cleanup_pb(atom_pb_backup);
-        delete atom_pb_backup;
-    }
-
     return (is_added);
 }
 
+#if 0
 bool swap_two_molecules(t_pack_molecule* molecule_1,
                         t_pack_molecule* molecule_2,
                         bool during_packing,
@@ -262,8 +223,8 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
     }
 
     //add the molecules to their new clusters
-    pack_1_result = try_pack_molecule(&(helper_ctx.cluster_placement_stats[block_1_type->index]),
-                                        molecule_1,
+    pack_2_result = try_pack_molecule(&(helper_ctx.cluster_placement_stats[block_1_type->index]),
+                                        molecule_2,
                                         helper_ctx.primitives_list,
                                         cluster_ctx.clb_nlist.block_pb(clb_1),
                                         helper_ctx.num_models,
@@ -277,8 +238,8 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
                                         target_ext_pin_util,
                                         temp_cluster_pr_1);
 
-    pack_2_result = try_pack_molecule(&(helper_ctx.cluster_placement_stats[block_2_type->index]),
-                                        molecule_2,
+    pack_1_result = try_pack_molecule(&(helper_ctx.cluster_placement_stats[block_2_type->index]),
+                                        molecule_1,
                                         helper_ctx.primitives_list,
                                         cluster_ctx.clb_nlist.block_pb(clb_2),
                                         helper_ctx.num_models,
@@ -292,6 +253,8 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
                                         target_ext_pin_util,
                                         temp_cluster_pr_2);
 
+    
+
     //commit the move if succeeded or revert if failed
     if (pack_1_result == BLK_PASSED && pack_2_result == BLK_PASSED) {
         if(during_packing) {
@@ -308,8 +271,8 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
 
         }
 
-        commit_mol_move(clb_1, clb_2, mol_1_pb_backup, old_1_router_data, clustering_data, during_packing, false);
-        commit_mol_move(clb_2, clb_1, mol_2_pb_backup, old_2_router_data, clustering_data, during_packing, false);
+        commit_mol_move(clb_1, clb_2, during_packing, false);
+        commit_mol_move(clb_2, clb_1, during_packing, false);
 
     } else {
         int atom_idx = 0;
@@ -357,4 +320,5 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
 
     //return the move result
     return (pack_1_result == BLK_PASSED && pack_2_result == BLK_PASSED);
-}
+}
+#endif

vpr/src/pack/re_cluster_util.cpp

@@ -49,8 +49,16 @@ std::vector<AtomBlockId> cluster_to_atoms(const ClusterBlockId& cluster) {
 bool remove_mol_from_cluster(const t_pack_molecule* molecule,
                              int molecule_size,
                              ClusterBlockId& old_clb,
-                             t_lb_router_data*& router_data) {
+                             t_lb_router_data*& router_data,
+                             t_clustering_data& clustering_data,
+                             bool during_packing) {
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
+    auto& atom_ctx = g_vpr_ctx.atom();
+    auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
+
+    t_pb* temp_pb = const_cast<t_pb*>(atom_ctx.lookup.atom_pb(molecule->atom_block_ids[0]));
+    t_pb* next_pb;
+
     //Determine the cluster ID
     old_clb = atom_to_cluster(molecule->atom_block_ids[molecule->root]);
     std::vector<AtomBlockId> old_clb_atoms = cluster_to_atoms(old_clb);
@@ -74,54 +82,28 @@ bool remove_mol_from_cluster(const t_pack_molecule* molecule,
                 revert_place_atom_block(molecule->atom_block_ids[i_atom], router_data);
             }
         }
-    }
 
+        cleanup_pb(cluster_ctx.clb_nlist.block_pb(old_clb));
+
+        if (during_packing) {
+            free_intra_lb_nets(clustering_data.intra_lb_routing[old_clb]);
+            clustering_data.intra_lb_routing[old_clb] = router_data->saved_lb_nets;
+            router_data->saved_lb_nets = nullptr;
+        } else {
+            cluster_ctx.clb_nlist.block_pb(old_clb)->pb_route.clear();
+            cluster_ctx.clb_nlist.block_pb(old_clb)->pb_route = alloc_and_load_pb_route(router_data->saved_lb_nets, cluster_ctx.clb_nlist.block_pb(old_clb)->pb_graph_node);
+        }
+    }
     //return true if succeeded
     return (is_cluster_legal);
 }
 
 void commit_mol_move(const ClusterBlockId& old_clb,
                      const ClusterBlockId& new_clb,
-                     std::vector<t_pb*>& mol_pbs,
-                     t_lb_router_data*& old_router_data,
-                     t_clustering_data& clustering_data,
                      bool during_packing,
                      bool new_clb_created) {
-    auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
     auto& device_ctx = g_vpr_ctx.device();
 
-    for (auto old_atom_pb : mol_pbs) {
-        t_pb* temp = old_atom_pb;
-        t_pb* next = temp->parent_pb;
-        //char* atom_name = vtr::strdup(temp->name);
-        bool has_more_children;
-
-        //delete atom pb
-        cleanup_pb(temp);
-
-        has_more_children = count_children_pbs(next);
-        //keep deleting the parent pbs if they were created only for the removed atom
-        while (!has_more_children) {
-            temp = next;
-            next = next->parent_pb;
-            cleanup_pb(temp);
-            has_more_children = count_children_pbs(next);
-        }
-    }
-
-    cluster_ctx.clb_nlist.block_pb(old_clb)->pb_route.clear();
-    cluster_ctx.clb_nlist.block_pb(old_clb)->pb_route = alloc_and_load_pb_route(old_router_data->saved_lb_nets, cluster_ctx.clb_nlist.block_pb(old_clb)->pb_graph_node);
-
-    if (during_packing) {
-        free_intra_lb_nets(clustering_data.intra_lb_routing[old_clb]);
-        //delete clustering_data.intra_lb_routing[old_clb];
-        clustering_data.intra_lb_routing[old_clb] = old_router_data->saved_lb_nets;
-        old_router_data->saved_lb_nets = nullptr;
-    }
-
-    free_router_data(old_router_data);
-    old_router_data = nullptr;
-
     if (!during_packing && new_clb_created) {
         int imacro;
         g_vpr_ctx.mutable_placement().block_locs.resize(g_vpr_ctx.placement().block_locs.size() + 1);
@@ -239,21 +221,23 @@ bool pack_mol_in_existing_cluster(t_pack_molecule* molecule,
     e_block_pack_status pack_result = BLK_STATUS_UNDEFINED;
     t_ext_pin_util target_ext_pin_util = helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(new_clb)->name);
     t_logical_block_type_ptr block_type = cluster_ctx.clb_nlist.block_type(new_clb);
+    t_pb* temp_pb = cluster_ctx.clb_nlist.block_pb(new_clb);
 
     //re-build router_data structure for this cluster
     t_lb_router_data* router_data = lb_load_router_data(helper_ctx.lb_type_rr_graphs, new_clb, new_clb_atoms);
 
     pack_result = try_pack_molecule(&(helper_ctx.cluster_placement_stats[block_type->index]),
                                     molecule,
                                     helper_ctx.primitives_list,
-                                    cluster_ctx.clb_nlist.block_pb(new_clb),
+                                    temp_pb,
                                     helper_ctx.num_models,
                                     helper_ctx.max_cluster_size,
                                     new_clb,
                                     E_DETAILED_ROUTE_FOR_EACH_ATOM,
                                     router_data,
                                     0,
-                                    helper_ctx.enable_pin_feasibility_filter,
+                                    //helper_ctx.enable_pin_feasibility_filter,
+                                    false,
                                     helper_ctx.feasible_block_array_size,
                                     target_ext_pin_util,
                                     temp_cluster_pr);
@@ -285,6 +269,40 @@ void fix_clustered_netlist(t_pack_molecule* molecule,
     fix_cluster_net_after_moving(molecule, molecule_size, old_clb, new_clb);
 }
 
+void revert_mol_move(const ClusterBlockId& old_clb,
+                     t_pack_molecule* molecule,
+                     t_lb_router_data*& old_router_data,
+                     bool during_packing,
+                     t_clustering_data& clustering_data) {
+    auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
+    auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
+
+    PartitionRegion temp_cluster_pr_original;
+    e_block_pack_status pack_result = try_pack_molecule(&(helper_ctx.cluster_placement_stats[cluster_ctx.clb_nlist.block_type(old_clb)->index]),
+                                                        molecule,
+                                                        helper_ctx.primitives_list,
+                                                        cluster_ctx.clb_nlist.block_pb(old_clb),
+                                                        helper_ctx.num_models,
+                                                        helper_ctx.max_cluster_size,
+                                                        old_clb,
+                                                        E_DETAILED_ROUTE_FOR_EACH_ATOM,
+                                                        old_router_data,
+                                                        0,
+                                                        helper_ctx.enable_pin_feasibility_filter,
+                                                        helper_ctx.feasible_block_array_size,
+                                                        helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(old_clb)->name),
+                                                        temp_cluster_pr_original);
+
+    VTR_ASSERT(pack_result == BLK_PASSED);
+    if (during_packing) {
+        free_intra_lb_nets(clustering_data.intra_lb_routing[old_clb]);
+        clustering_data.intra_lb_routing[old_clb] = old_router_data->saved_lb_nets;
+        old_router_data->saved_lb_nets = nullptr;
+    } else {
+        cluster_ctx.clb_nlist.block_pb(old_clb)->pb_route.clear();
+        cluster_ctx.clb_nlist.block_pb(old_clb)->pb_route = alloc_and_load_pb_route(old_router_data->saved_lb_nets, cluster_ctx.clb_nlist.block_pb(old_clb)->pb_graph_node);
+    }
+}
 /*******************************************/
 /************ static functions *************/
 /*******************************************/
@@ -592,4 +610,37 @@ static bool count_children_pbs(const t_pb* pb) {
         }
     }
     return false;
-}
+}
+
+#if 1
+void rebuild_cluster_placemet_stats(const ClusterBlockId& clb_index,
+                                    const std::vector<AtomBlockId>& clb_atoms,
+                                    int type_idx,
+                                    int mode) {
+    auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+    auto& atom_ctx = g_vpr_ctx.atom();
+
+    t_cluster_placement_stats* cluster_placement_stats = &(helper_ctx.cluster_placement_stats[type_idx]);
+
+    reset_cluster_placement_stats(cluster_placement_stats);
+    set_mode_cluster_placement_stats(cluster_ctx.clb_nlist.block_pb(clb_index)->pb_graph_node, mode);
+
+    std::set<t_pb_graph_node*> list_of_pb_atom_nodes;
+    t_cluster_placement_primitive* cur_cluster_placement_primitive;
+
+    for (auto& atom_blk : clb_atoms) {
+        list_of_pb_atom_nodes.insert(atom_ctx.lookup.atom_pb(atom_blk)->pb_graph_node);
+    }
+
+    for (int i = 0; i < cluster_placement_stats->num_pb_types; i++) {
+        cur_cluster_placement_primitive = cluster_placement_stats->valid_primitives[i]->next_primitive;
+        while (cur_cluster_placement_primitive != nullptr) {
+            if (list_of_pb_atom_nodes.find(cur_cluster_placement_primitive->pb_graph_node) != list_of_pb_atom_nodes.end()) {
+                cur_cluster_placement_primitive->valid = false;
+            }
+            cur_cluster_placement_primitive = cur_cluster_placement_primitive->next_primitive;
+        }
+    }
+}
+#endif