cluster_to_atoms() returns a reference

soheilshahrouz · soheilshahrouz · commit 8a32b610c8c7 · 2024-06-10T15:50:53.000-04:00
diff --git a/vpr/src/base/vpr_constraints_writer.cpp b/vpr/src/base/vpr_constraints_writer.cpp
@@ -80,9 +80,9 @@ void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints, int ex
         part.set_part_region(pr);
         constraints.mutable_place_constraints().add_partition(part);
 
-        std::unordered_set<AtomBlockId>* atoms = cluster_to_atoms(blk_id);
+        const std::unordered_set<AtomBlockId>& atoms = cluster_to_atoms(blk_id);
 
-        for (auto atom_id : *atoms) {
+        for (AtomBlockId atom_id : atoms) {
             constraints.mutable_place_constraints().add_constrained_atom(atom_id, partid);
         }
         part_id++;
@@ -156,7 +156,7 @@ void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints, int
      * appropriate region accordingly
      */
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
-        std::unordered_set<AtomBlockId>* atoms = cluster_to_atoms(blk_id);
+        const std::unordered_set<AtomBlockId>& atoms = cluster_to_atoms(blk_id);
         int x = place_ctx.block_locs[blk_id].loc.x;
         int y = place_ctx.block_locs[blk_id].loc.y;
         int width = device_ctx.grid.width();
@@ -189,7 +189,7 @@ void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints, int
 
         VTR_ASSERT(got != region_atoms.end());
 
-        for (auto atom_id : *atoms) {
+        for (AtomBlockId atom_id : atoms) {
             got->second.push_back(atom_id);
         }
     }
diff --git a/vpr/src/pack/re_cluster.cpp b/vpr/src/pack/re_cluster.cpp
@@ -37,8 +37,8 @@ bool move_mol_to_new_cluster(t_pack_molecule* molecule,
     }
 
     //remove the molecule from its current cluster
-    std::unordered_set<AtomBlockId>* old_clb_atoms = cluster_to_atoms(old_clb);
-    if (old_clb_atoms->size() == 1) {
+    std::unordered_set<AtomBlockId>& old_clb_atoms = cluster_to_mutable_atoms(old_clb);
+    if (old_clb_atoms.size() == 1) {
         VTR_LOGV(verbosity > 4, "Atom: %zu move failed. This is the last atom in its cluster.\n");
         return false;
     }
@@ -109,7 +109,7 @@ bool move_mol_to_existing_cluster(t_pack_molecule* molecule,
     AtomBlockId root_atom_id = molecule->atom_block_ids[molecule->root];
     int molecule_size = get_array_size_of_molecule(molecule);
     t_lb_router_data* old_router_data = nullptr;
-    std::unordered_set<AtomBlockId>* new_clb_atoms = cluster_to_atoms(new_clb);
+    std::unordered_set<AtomBlockId>& new_clb_atoms = cluster_to_mutable_atoms(new_clb);
     ClusterBlockId old_clb = atom_to_cluster(root_atom_id);
 
     //check old and new clusters compitability
@@ -118,8 +118,8 @@ bool move_mol_to_existing_cluster(t_pack_molecule* molecule,
         return false;
 
     //remove the molecule from its current cluster
-    std::unordered_set<AtomBlockId>* old_clb_atoms = cluster_to_atoms(old_clb);
-    if (old_clb_atoms->size() == 1) {
+    std::unordered_set<AtomBlockId>& old_clb_atoms = cluster_to_mutable_atoms(old_clb);
+    if (old_clb_atoms.size() == 1) {
         VTR_LOGV(verbosity > 4, "Atom: %zu move failed. This is the last atom in its cluster.\n");
         return false;
     }
@@ -197,11 +197,13 @@ bool swap_two_molecules(t_pack_molecule* molecule_1,
     t_lb_router_data* old_2_router_data = nullptr;
 
     //save the atoms of the 2 clusters
-    std::unordered_set<AtomBlockId>* clb_1_atoms = cluster_to_atoms(clb_1);
-    std::unordered_set<AtomBlockId>* clb_2_atoms = cluster_to_atoms(clb_2);
+    std::unordered_set<AtomBlockId>& clb_1_atoms = cluster_to_mutable_atoms(clb_1);
+    std::unordered_set<AtomBlockId>& clb_2_atoms = cluster_to_mutable_atoms(clb_2);
 
-    if (clb_1_atoms->size() == 1 || clb_2_atoms->size() == 1) {
-        VTR_LOGV(verbosity > 4, "Atom: %zu, %zu swap failed. This is the last atom in its cluster.\n", molecule_1->atom_block_ids[molecule_1->root], molecule_2->atom_block_ids[molecule_2->root]);
+    if (clb_1_atoms.size() == 1 || clb_2_atoms.size() == 1) {
+        VTR_LOGV(verbosity > 4, "Atom: %zu, %zu swap failed. This is the last atom in its cluster.\n",
+                 molecule_1->atom_block_ids[molecule_1->root],
+                 molecule_2->atom_block_ids[molecule_2->root]);
         return false;
     }
 
diff --git a/vpr/src/pack/re_cluster_util.cpp b/vpr/src/pack/re_cluster_util.cpp
@@ -34,7 +34,7 @@ static void fix_cluster_net_after_moving(const t_pack_molecule* molecule,
                                          const ClusterBlockId& new_clb);
 
 static void rebuild_cluster_placement_stats(const ClusterBlockId& clb_index,
-                                            const std::unordered_set<AtomBlockId>* clb_atoms);
+                                            const std::unordered_set<AtomBlockId>& clb_atoms);
 
 static void update_cluster_pb_stats(const t_pack_molecule* molecule,
                                     int molecule_size,
@@ -47,29 +47,25 @@ ClusterBlockId atom_to_cluster(const AtomBlockId& atom) {
     return (atom_ctx.lookup.atom_clb(atom));
 }
 
-std::unordered_set<AtomBlockId>* cluster_to_atoms(const ClusterBlockId& cluster) {
-    auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
+const std::unordered_set<AtomBlockId>& cluster_to_atoms(ClusterBlockId cluster) {
+    const auto& atoms = cluster_to_mutable_atoms(cluster);
 
-    //If the lookup is not built yet, build it first
-    if (helper_ctx.atoms_lookup.empty())
-        init_clb_atoms_lookup(helper_ctx.atoms_lookup);
-
-    return &(helper_ctx.atoms_lookup[cluster]);
+    return atoms;
 }
 
 void remove_mol_from_cluster(const t_pack_molecule* molecule,
                              int molecule_size,
                              ClusterBlockId& old_clb,
-                             std::unordered_set<AtomBlockId>* old_clb_atoms,
+                             std::unordered_set<AtomBlockId>& old_clb_atoms,
                              bool router_data_ready,
                              t_lb_router_data*& router_data) {
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
 
     for (int i_atom = 0; i_atom < molecule_size; i_atom++) {
         if (molecule->atom_block_ids[i_atom]) {
-            auto it = old_clb_atoms->find(molecule->atom_block_ids[i_atom]);
-            if (it != old_clb_atoms->end())
-                old_clb_atoms->erase(molecule->atom_block_ids[i_atom]);
+            auto it = old_clb_atoms.find(molecule->atom_block_ids[i_atom]);
+            if (it != old_clb_atoms.end())
+                old_clb_atoms.erase(molecule->atom_block_ids[i_atom]);
         }
     }
 
@@ -96,18 +92,16 @@ void commit_mol_move(const ClusterBlockId& old_clb,
     }
 }
 
-t_lb_router_data* lb_load_router_data(std::vector<t_lb_type_rr_node>* lb_type_rr_graphs, const ClusterBlockId& clb_index, const std::unordered_set<AtomBlockId>* clb_atoms) {
+t_lb_router_data* lb_load_router_data(std::vector<t_lb_type_rr_node>* lb_type_rr_graphs,
+                                      const ClusterBlockId& clb_index,
+                                      const std::unordered_set<AtomBlockId>& clb_atoms) {
     //build data structures used by intra-logic block router
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& atom_ctx = g_vpr_ctx.atom();
     auto block_type = cluster_ctx.clb_nlist.block_type(clb_index);
     t_lb_router_data* router_data = alloc_and_load_router_data(&lb_type_rr_graphs[block_type->index], block_type);
 
-    //iterate over atoms of the current cluster and add them to router data
-    if (!clb_atoms)
-        return router_data;
-
-    for (auto atom_id : *clb_atoms) {
+    for (auto atom_id : clb_atoms) {
         add_atom_as_target(router_data, atom_id);
         const t_pb* pb = atom_ctx.lookup.atom_pb(atom_id);
         while (pb) {
@@ -209,7 +203,7 @@ bool start_new_cluster_for_mol(t_pack_molecule* molecule,
 bool pack_mol_in_existing_cluster(t_pack_molecule* molecule,
                                   int molecule_size,
                                   const ClusterBlockId& new_clb,
-                                  std::unordered_set<AtomBlockId>* new_clb_atoms,
+                                  std::unordered_set<AtomBlockId>& new_clb_atoms,
                                   bool during_packing,
                                   t_clustering_data& clustering_data,
                                   t_lb_router_data*& router_data) {
@@ -262,7 +256,7 @@ bool pack_mol_in_existing_cluster(t_pack_molecule* molecule,
 
         for (int i_atom = 0; i_atom < molecule_size; i_atom++) {
             if (molecule->atom_block_ids[i_atom]) {
-                new_clb_atoms->insert(molecule->atom_block_ids[i_atom]);
+                new_clb_atoms.insert(molecule->atom_block_ids[i_atom]);
             }
         }
         update_cluster_pb_stats(molecule, molecule_size, new_clb, true);
@@ -364,10 +358,10 @@ static void fix_cluster_net_after_moving(const t_pack_molecule* molecule,
     fix_cluster_pins_after_moving(old_clb);
     fix_cluster_pins_after_moving(new_clb);
 
-    for (auto& atom_blk : *(cluster_to_atoms(old_clb)))
+    for (AtomBlockId atom_blk : cluster_to_atoms(old_clb))
         fix_atom_pin_mapping(atom_blk);
 
-    for (auto& atom_blk : *(cluster_to_atoms(new_clb)))
+    for (AtomBlockId atom_blk : cluster_to_atoms(new_clb))
         fix_atom_pin_mapping(atom_blk);
 
     cluster_ctx.clb_nlist.remove_and_compress();
@@ -641,7 +635,7 @@ static bool count_children_pbs(const t_pb* pb) {
 #endif
 
 static void rebuild_cluster_placement_stats(const ClusterBlockId& clb_index,
-                                            const std::unordered_set<AtomBlockId>* clb_atoms) {
+                                            const std::unordered_set<AtomBlockId>& clb_atoms) {
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& atom_ctx = g_vpr_ctx.atom();
@@ -650,7 +644,7 @@ static void rebuild_cluster_placement_stats(const ClusterBlockId& clb_index,
     reset_cluster_placement_stats(cluster_placement_stats);
     set_mode_cluster_placement_stats(cluster_ctx.clb_nlist.block_pb(clb_index)->pb_graph_node, cluster_ctx.clb_nlist.block_pb(clb_index)->mode);
 
-    for (auto& atom : *clb_atoms) {
+    for (AtomBlockId atom : clb_atoms) {
         const t_pb* atom_pb = atom_ctx.lookup.atom_pb(atom);
         commit_primitive(cluster_placement_stats, atom_pb->pb_graph_node);
     }
@@ -744,3 +738,13 @@ static void update_cluster_pb_stats(const t_pack_molecule* molecule,
         }
     }
 }
+
+std::unordered_set<AtomBlockId>& cluster_to_mutable_atoms(ClusterBlockId cluster) {
+    auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
+
+    //If the lookup is not built yet, build it first
+    if (helper_ctx.atoms_lookup.empty())
+        init_clb_atoms_lookup(helper_ctx.atoms_lookup);
+
+    return helper_ctx.atoms_lookup[cluster];
+}
diff --git a/vpr/src/pack/re_cluster_util.h b/vpr/src/pack/re_cluster_util.h
@@ -27,17 +27,26 @@ ClusterBlockId atom_to_cluster(const AtomBlockId& atom);
 
 /**
  * @brief A function that return a list of atoms in a cluster
- * @note This finction can be called only after cluster/packing is done or
- * the clustered netlist is created
+ * @note This function can be called only after cluster/packing is done or
+ * the clustered netlist is created.
+ * @return Atoms in the given cluster. The returned set is immutable.
  */
+const std::unordered_set<AtomBlockId>& cluster_to_atoms(ClusterBlockId cluster);
+
+/**
+ * @brief A function that return a list of atoms in a cluster
+ * @note This function can be called only after cluster/packing is done or
+ * the clustered netlist is created.
+ * @return Atoms in the given cluster. The returned set is mutable.
+ */
+std::unordered_set<AtomBlockId>& cluster_to_mutable_atoms(ClusterBlockId cluster);
 
-std::unordered_set<AtomBlockId>* cluster_to_atoms(const ClusterBlockId& cluster);
 /**
  * @brief A function that loads the intra-cluster router data of one cluster
  */
 t_lb_router_data* lb_load_router_data(std::vector<t_lb_type_rr_node>* lb_type_rr_graphs,
                                       const ClusterBlockId& clb_index,
-                                      const std::unordered_set<AtomBlockId>* clb_atoms);
+                                      const std::unordered_set<AtomBlockId>& clb_atoms);
 
 /**
  * @brief A function that removes a molecule from a cluster and checks legality of
@@ -58,7 +67,7 @@ t_lb_router_data* lb_load_router_data(std::vector<t_lb_type_rr_node>* lb_type_rr
 void remove_mol_from_cluster(const t_pack_molecule* molecule,
                              int molecule_size,
                              ClusterBlockId& old_clb,
-                             std::unordered_set<AtomBlockId>* old_clb_atoms,
+                             std::unordered_set<AtomBlockId>& old_clb_atoms,
                              bool router_data_ready,
                              t_lb_router_data*& router_data);
 
@@ -105,7 +114,7 @@ bool start_new_cluster_for_mol(t_pack_molecule* molecule,
 bool pack_mol_in_existing_cluster(t_pack_molecule* molecule,
                                   int molecule_size,
                                   const ClusterBlockId& new_clb,
-                                  std::unordered_set<AtomBlockId>* new_clb_atoms,
+                                  std::unordered_set<AtomBlockId>& new_clb_atoms,
                                   bool during_packing,
                                   t_clustering_data& clustering_data,
                                   t_lb_router_data*& router_data);
diff --git a/vpr/src/place/place_constraints.cpp b/vpr/src/place/place_constraints.cpp
@@ -245,13 +245,13 @@ void load_cluster_constraints() {
     floorplanning_ctx.cluster_constraints.resize(cluster_ctx.clb_nlist.blocks().size());
 
     for (auto cluster_id : cluster_ctx.clb_nlist.blocks()) {
-        std::unordered_set<AtomBlockId>* atoms = cluster_to_atoms(cluster_id);
+        const std::unordered_set<AtomBlockId>& atoms = cluster_to_atoms(cluster_id);
         PartitionRegion empty_pr;
         floorplanning_ctx.cluster_constraints[cluster_id] = empty_pr;
 
         //if there are any constrained atoms in the cluster,
         //we update the cluster's PartitionRegion
-        for (auto atom : *atoms) {
+        for (AtomBlockId atom : atoms) {
             PartitionId partid = floorplanning_ctx.constraints.get_atom_partition(atom);
 
             if (partid != PartitionId::INVALID()) {
diff --git a/vpr/src/place/place_constraints.h b/vpr/src/place/place_constraints.h
@@ -71,7 +71,12 @@ inline bool floorplan_legal(const t_pl_blocks_to_be_moved& blocks_affected) {
     for (int i = 0; i < blocks_affected.num_moved_blocks; i++) {
         floorplan_legal = cluster_floorplanning_legal(blocks_affected.moved_blocks[i].block_num, blocks_affected.moved_blocks[i].new_loc);
         if (!floorplan_legal) {
-            VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\tMove aborted for block %zu, location tried was x: %d, y: %d, subtile: %d \n", size_t(blocks_affected.moved_blocks[i].block_num), blocks_affected.moved_blocks[i].new_loc.x, blocks_affected.moved_blocks[i].new_loc.y, blocks_affected.moved_blocks[i].new_loc.sub_tile);
+            VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug,
+                           "\tMove aborted for block %zu, location tried was x: %d, y: %d, subtile: %d \n",
+                           size_t(blocks_affected.moved_blocks[i].block_num),
+                           blocks_affected.moved_blocks[i].new_loc.x,
+                           blocks_affected.moved_blocks[i].new_loc.y,
+                           blocks_affected.moved_blocks[i].new_loc.sub_tile);
             return false;
         }
     }
@@ -96,6 +101,10 @@ void load_cluster_constraints();
  */
 void mark_fixed_blocks();
 
+/**
+ * @brief Converts the floorplanning constraints from grid location to
+ * compressed grid locations and store them in FloorplanningContext.
+ */
 void alloc_and_load_compressed_cluster_constraints();
 
 /*
diff --git a/vpr/src/util/vpr_utils.cpp b/vpr/src/util/vpr_utils.cpp
@@ -1372,8 +1372,8 @@ std::vector<int> get_cluster_internal_class_pairs(const AtomLookup& atom_lookup,
     std::tie(physical_tile, sub_tile, rel_cap, logical_block) = get_cluster_blk_physical_spec(cluster_block_id);
     class_num_vec.reserve(physical_tile->primitive_class_inf.size());
 
-    const auto& cluster_atoms = *cluster_to_atoms(cluster_block_id);
-    for (auto atom_blk_id : cluster_atoms) {
+    const auto& cluster_atoms = cluster_to_atoms(cluster_block_id);
+    for (AtomBlockId atom_blk_id : cluster_atoms) {
         auto atom_pb_graph_node = atom_lookup.atom_pb_graph_node(atom_blk_id);
         auto class_range = get_pb_graph_node_class_physical_range(physical_tile,
                                                                   sub_tile,
