swapping two molecule first implementation (WIP)

Author: MohamedElgammal

vpr/src/pack/re_cluster.cpp

@@ -144,10 +144,11 @@ bool move_mol_to_existing_cluster(t_pack_molecule* molecule,
     return (is_added);
 }
 
-#if 0
+#if 1
 bool swap_two_molecules(t_pack_molecule* molecule_1,
                         t_pack_molecule* molecule_2,
                         bool during_packing,
+                        int verbosity,
                         t_clustering_data& clustering_data) {
     //define required contexts
     auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -157,8 +158,7 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
     //define local variables
     PartitionRegion temp_cluster_pr_1, temp_cluster_pr_2;
 
-    e_block_pack_status pack_1_result = BLK_STATUS_UNDEFINED;
-    e_block_pack_status pack_2_result = BLK_STATUS_UNDEFINED;
+    bool mol_1_success, mol_2_success;
 
     AtomBlockId root_1_atom_id = molecule_1->atom_block_ids[molecule_1->root];
     AtomBlockId root_2_atom_id = molecule_2->atom_block_ids[molecule_2->root];
@@ -170,25 +170,17 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
     ClusterBlockId clb_1 = atom_to_cluster(root_1_atom_id);
     ClusterBlockId clb_2 = atom_to_cluster(root_2_atom_id);
 
-    t_logical_block_type_ptr block_1_type = cluster_ctx.clb_nlist.block_type(clb_1);
-    t_logical_block_type_ptr block_2_type = cluster_ctx.clb_nlist.block_type(clb_2);
+    //t_logical_block_type_ptr block_1_type = cluster_ctx.clb_nlist.block_type(clb_1);
+    //t_logical_block_type_ptr block_2_type = cluster_ctx.clb_nlist.block_type(clb_2);
 
-    t_ext_pin_util target_ext_pin_util = helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(clb_1)->name);
+    //t_ext_pin_util target_ext_pin_util = helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(clb_1)->name);
 
     //Check that the old and new clusters are of the same type
-    if (cluster_ctx.clb_nlist.block_type(clb_1) != cluster_ctx.clb_nlist.block_type(clb_2)) {
-        VTR_LOG("swapping atoms:(%zu, %zu) is aborted. The 2 cluster blocks are not of the same type",
-                root_1_atom_id, root_2_atom_id);
-        return false;
-    }
-
-    //Check that the old and new clusters are of the same mode
-    if (cluster_ctx.clb_nlist.block_pb(clb_1)->mode != cluster_ctx.clb_nlist.block_pb(clb_2)->mode) {
-        VTR_LOG("swapping atoms:(%zu, %zu) is aborted. The 2 cluster blocks are not of the same mode",
-                root_1_atom_id, root_2_atom_id);
+    bool is_compitable = check_type_and_mode_compitability(clb_1, clb_2, verbosity);
+    if (!is_compitable)
         return false;
-    }
 
+#if 0
     //Backup the original pb of the molecule before the move
     std::vector<t_pb*> mol_1_pb_backup, mol_2_pb_backup;
     for (int i_atom = 0; i_atom < molecule_1_size; i_atom++) {
@@ -205,126 +197,70 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
             mol_2_pb_backup.push_back(atom_pb_backup);
         }
     }
+#endif
 
-    //save the atoms of the 2 clusters
-    std::vector<AtomBlockId> clb_1_atoms = cluster_to_atoms(clb_1);
-    std::vector<AtomBlockId> clb_2_atoms = cluster_to_atoms(clb_2);
+    t_lb_router_data* old_1_router_data = nullptr;
+    t_lb_router_data* old_2_router_data = nullptr;
 
-    //re-load the intra-cluster routing
-    t_lb_router_data* old_1_router_data = lb_load_router_data(helper_ctx.lb_type_rr_graphs, clb_1, clb_1_atoms);
-    t_lb_router_data* old_2_router_data = lb_load_router_data(helper_ctx.lb_type_rr_graphs, clb_2, clb_2_atoms);
+    //remove the molecule from its current cluster
+    remove_mol_from_cluster(molecule_1, molecule_1_size, clb_1, old_1_router_data);
+    //remove_mol_from_cluster(molecule_2, molecule_2_size, clb_2, old_2_router_data);
+    
+    //bool is_removed = is_cluster_legal(old_1_router_data);
+    //bool is_removed_2 = is_cluster_legal(old_2_router_data);
 
-    //remove molecules from their old clusters
-    for(int i_atom = 0; i_atom < molecule_1_size; i_atom++) {
-        if(molecule_1->atom_block_ids[i_atom]) {
-            remove_atom_from_target(old_1_router_data, molecule_1->atom_block_ids[i_atom]);
+    //commit_mol_removal(molecule_1, molecule_1_size, clb_1, during_packing, old_1_router_data, clustering_data);
+    //commit_mol_removal(molecule_2, molecule_2_size, clb_2, during_packing, old_2_router_data, clustering_data);
+    for (int i_atom = 0; i_atom < molecule_1_size; i_atom++) {
+        if (molecule_1->atom_block_ids[i_atom]) {
             revert_place_atom_block(molecule_1->atom_block_ids[i_atom], old_1_router_data);
         }
     }
-    for(int i_atom = 0; i_atom < molecule_2_size; i_atom++) {
-        if(molecule_2->atom_block_ids[i_atom]) {
-            remove_atom_from_target(old_2_router_data, molecule_2->atom_block_ids[i_atom]);
-            revert_place_atom_block(molecule_2->atom_block_ids[i_atom], old_2_router_data);
-        }
-    }
 
-    //add the molecules to their new clusters
-    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,
-                                        helper_ctx.max_cluster_size,
-                                        clb_1,
-                                        E_DETAILED_ROUTE_FOR_EACH_ATOM,
-                                        old_1_router_data,
-                                        0,
-                                        helper_ctx.enable_pin_feasibility_filter,
-                                        helper_ctx.feasible_block_array_size,
-                                        target_ext_pin_util,
-                                        temp_cluster_pr_1);
-
-    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,
-                                        helper_ctx.max_cluster_size,
-                                        clb_2,
-                                        E_DETAILED_ROUTE_FOR_EACH_ATOM,
-                                        old_2_router_data,
-                                        0,
-                                        helper_ctx.enable_pin_feasibility_filter,
-                                        helper_ctx.feasible_block_array_size,
-                                        target_ext_pin_util,
-                                        temp_cluster_pr_2);
+    cleanup_pb(cluster_ctx.clb_nlist.block_pb(clb_1));    
+    bool is_removed = is_cluster_legal(old_1_router_data);
+    free_intra_lb_nets(clustering_data.intra_lb_routing[clb_1]);
+    clustering_data.intra_lb_routing[clb_1] = old_1_router_data->saved_lb_nets;
+    old_1_router_data->saved_lb_nets = nullptr;
 
+    //save the atoms of the 2 clusters
+    std::vector<AtomBlockId> clb_1_atoms = cluster_to_atoms(clb_1);
+    std::vector<AtomBlockId> clb_2_atoms = cluster_to_atoms(clb_2);
 
+    //Add the atom to the new cluster
+    mol_1_success = pack_mol_in_existing_cluster(molecule_1, clb_2, clb_2_atoms, during_packing, clustering_data);
+    //mol_2_success = pack_mol_in_existing_cluster(molecule_2, clb_1, clb_1_atoms, during_packing, clustering_data);
+    mol_2_success = true;
 
     //commit the move if succeeded or revert if failed
-    if (pack_1_result == BLK_PASSED && pack_2_result == BLK_PASSED) {
-        if(during_packing) {
-            free_intra_lb_nets(clustering_data.intra_lb_routing[clb_1]);
-            free_intra_lb_nets(clustering_data.intra_lb_routing[clb_2]);
-
-            clustering_data.intra_lb_routing[clb_1] = old_1_router_data->saved_lb_nets;
-            clustering_data.intra_lb_routing[clb_2] = old_2_router_data->saved_lb_nets;
-        } else {
-            cluster_ctx.clb_nlist.block_pb(clb_1)->pb_route.clear();
-            cluster_ctx.clb_nlist.block_pb(clb_1)->pb_route = alloc_and_load_pb_route(old_1_router_data->saved_lb_nets, cluster_ctx.clb_nlist.block_pb(clb_1)->pb_graph_node);
-            cluster_ctx.clb_nlist.block_pb(clb_2)->pb_route.clear();
-            cluster_ctx.clb_nlist.block_pb(clb_2)->pb_route = alloc_and_load_pb_route(old_2_router_data->saved_lb_nets, cluster_ctx.clb_nlist.block_pb(clb_1)->pb_graph_node);
-
-        }
-
+    if (mol_1_success && mol_2_success) {
         commit_mol_move(clb_1, clb_2, during_packing, false);
-        commit_mol_move(clb_2, clb_1, during_packing, false);
-        
+        //commit_mol_move(clb_2, clb_1, during_packing, false);
+        VTR_LOGV(verbosity > 4, "Molecules swap is performed successfully\n");
     } else {
-        int atom_idx = 0;
-        for(int i_atom = 0; i_atom < molecule_1_size; i_atom++) {
-            if(molecule_1->atom_block_ids[i_atom]) {
-                atom_ctx.lookup.set_atom_clb(molecule_1->atom_block_ids[i_atom], clb_1);
-                atom_ctx.lookup.set_atom_pb(molecule_1->atom_block_ids[i_atom], mol_1_pb_backup[atom_idx]);
-            }
-        }
-
-        atom_idx = 0;
-        for(int i_atom = 0; i_atom < molecule_2_size; i_atom++) {
-            if(molecule_2->atom_block_ids[i_atom]) {
-                atom_ctx.lookup.set_atom_clb(molecule_2->atom_block_ids[i_atom], clb_2);
-                atom_ctx.lookup.set_atom_pb(molecule_2->atom_block_ids[i_atom], mol_2_pb_backup[atom_idx]);
-            }
-        }
+        revert_mol_move(clb_1, molecule_1, old_1_router_data, during_packing, clustering_data);
+        //revert_mol_move(clb_2, molecule_2, old_2_router_data, during_packing, clustering_data);
+        VTR_LOGV(verbosity > 4, "Molecules swap failed\n");
     }
 
+
     //If the move is done after packing not during it, some fixes need to be done on the clustered netlist
-    if(pack_1_result == BLK_PASSED && pack_2_result == BLK_PASSED && !during_packing) {
+    if (mol_1_success && mol_2_success && !during_packing) {
         fix_clustered_netlist(molecule_1, molecule_1_size, clb_1, clb_2);
-        fix_clustered_netlist(molecule_2, molecule_2_size, clb_2, clb_1);
+        //fix_clustered_netlist(molecule_2, molecule_2_size, clb_2, clb_1);
     }
 
     //free memory
-    old_1_router_data->saved_lb_nets = nullptr;
-    old_2_router_data->saved_lb_nets = nullptr;
+    //old_1_router_data->saved_lb_nets = nullptr;
+    //old_2_router_data->saved_lb_nets = nullptr;
 
     free_router_data(old_1_router_data);
-    free_router_data(old_2_router_data);
+    //free_router_data(old_2_router_data);
 
     old_1_router_data = nullptr;
-    old_2_router_data = nullptr;
-
-    //free backup memory
-    for(auto atom_pb_backup : mol_1_pb_backup) {
-        cleanup_pb(atom_pb_backup);
-        delete atom_pb_backup;
-    }
-    for(auto atom_pb_backup : mol_2_pb_backup) {
-        cleanup_pb(atom_pb_backup);
-        delete atom_pb_backup;
-    }
+    //old_2_router_data = nullptr;
 
     //return the move result
-    return (pack_1_result == BLK_PASSED && pack_2_result == BLK_PASSED);
+    return (mol_1_success && mol_2_success);
 }
 #endif

vpr/src/pack/re_cluster.h

@@ -52,5 +52,6 @@ bool move_mol_to_existing_cluster(t_pack_molecule* molecule,
 bool swap_two_molecules(t_pack_molecule* molecule_1,
                         t_pack_molecule* molecule_2,
                         bool during_packing,
+                        int verbosity,
                         t_clustering_data& clustering_data);
 #endif