[SQUASH ME] Removed Clustered Netlist from Packer

Author: AlexandreSinger

vpr/src/base/clustered_netlist.cpp

@@ -171,12 +171,8 @@ ClusterNetId ClusteredNetlist::create_net(const std::string& name) {
 
 void ClusteredNetlist::remove_block_impl(const ClusterBlockId blk_id) {
     //Remove & invalidate pointers
-    // FIXME: This cannot set the pb to nullptr properly, causing it to double
-    //        free... Need some way to transfer ownership.
-    /*
     free_pb(block_pbs_[blk_id]);
     delete block_pbs_[blk_id];
-    */
     block_pbs_.insert(blk_id, NULL);
     block_types_.insert(blk_id, NULL);
     block_logical_pins_.insert(blk_id, std::vector<ClusterPinId>());

vpr/src/base/vpr_context.h

@@ -36,6 +36,7 @@
 #include "noc_routing.h"
 #include "tatum/report/TimingPath.hpp"
 #include "blk_loc_registry.h"
+#include "vtr_vector_map.h"
 
 #ifndef NO_SERVER
 
@@ -320,8 +321,17 @@ struct ClusteringHelperContext : public Context {
     int max_cluster_size;
 
     // total number of CLBs
+    // TODO: Rename to num_legalized_clusters.
+    //  - Maybe even remove this if it becomes trivial.
     int total_clb_num;
 
+    std::vector<LegalizationClusterId> legalized_clusters;
+    // FIXME: These are overshadowed by the legalizer which can return these!
+    //  - They can just be removed and use the cluster legalizer as the lookup.
+    //  - This also gets invalidated by the compress, making it uber wrong!
+    vtr::vector_map<LegalizationClusterId, t_pb*> cluster_pb;
+    vtr::vector_map<LegalizationClusterId, t_logical_block_type_ptr> cluster_type;
+
     // A vector of routing resource nodes within each of logic cluster_ctx.blocks types [0 .. num_logical_block_type-1]
     // FIXME: This is only used for a handoff between the vpr_setup and the packer.
     //        This can be made cleaner.

vpr/src/pack/cluster.cpp

@@ -75,8 +75,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                          bool balance_block_type_utilization,
                                                          AttractionInfo& attraction_groups,
                                                          bool& floorplan_regions_overfull,
-                                                         t_clustering_data& clustering_data,
-                                                         size_t num_models) {
+                                                         t_clustering_data& clustering_data) {
     /* Does the actual work of clustering multiple netlist blocks *
      * into clusters.                                                  */
 
@@ -120,7 +119,6 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
     auto& atom_ctx = g_vpr_ctx.atom();
     auto& device_ctx = g_vpr_ctx.mutable_device();
-    auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
 
     std::shared_ptr<PreClusterDelayCalculator> clustering_delay_calc;
@@ -136,12 +134,15 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     // Index 2 holds the number of LEs that are used for registers only.
     std::vector<int> le_count(3, 0);
 
+    // helper_ctx.legalized_clusters.clear();
+    helper_ctx.cluster_pb.clear();
+    helper_ctx.cluster_type.clear();
     helper_ctx.total_clb_num = 0;
 
     /* TODO: This is memory inefficient, fix if causes problems */
     /* Store stats on nets used by packed block, useful for determining transitively connected blocks
      * (eg. [A1, A2, ..]->[B1, B2, ..]->C implies cluster [A1, A2, ...] and C have a weak link) */
-    vtr::vector<ClusterBlockId, std::vector<AtomNetId>> clb_inter_blk_nets(atom_ctx.nlist.blocks().size());
+    vtr::vector<LegalizationClusterId, std::vector<AtomNetId>> clb_inter_blk_nets(atom_ctx.nlist.blocks().size());
 
     istart = nullptr;
 
@@ -228,24 +229,16 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
             // FIXME: Pass in the cluster legalizer.
             helper_ctx.cluster_legalizer.set_legalization_strategy(strategy);
 
-            // FIXME: Remove the reference to the clustered netlist. It is not
-            //        even correct.
-            //  - Or maybe we can just leave it for now. This is more of a
-            //    clustering issue and not a legalizer issue.
-            // Use the total number created clusters so far as the ID for the new cluster
-            ClusterBlockId clb_index(helper_ctx.total_clb_num);
             LegalizationClusterId legalization_cluster_id;
 
             VTR_LOGV(verbosity > 2, "Complex block %d:\n", helper_ctx.total_clb_num);
 
             start_new_cluster(helper_ctx.cluster_legalizer,
-                              clb_index,
                               legalization_cluster_id,
                               istart,
                               num_used_type_instances,
                               packer_opts.target_device_utilization,
                               arch, packer_opts.device_layout,
-                              &cluster_ctx.clb_nlist,
                               primitive_candidate_block_types,
                               verbosity,
                               balance_block_type_utilization);
@@ -263,14 +256,14 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
             VTR_LOGV(verbosity > 2,
                      "Complex block %d: '%s' (%s) ", helper_ctx.total_clb_num,
-                     cluster_ctx.clb_nlist.block_name(clb_index).c_str(),
-                     cluster_ctx.clb_nlist.block_type(clb_index)->name);
+                     helper_ctx.cluster_pb[legalization_cluster_id]->name,
+                     helper_ctx.cluster_type[legalization_cluster_id]->name);
             VTR_LOGV(verbosity > 2, ".");
             //Progress dot for seed-block
             fflush(stdout);
 
-            int high_fanout_threshold = helper_ctx.high_fanout_thresholds.get_threshold(cluster_ctx.clb_nlist.block_type(clb_index)->name);
-            update_cluster_stats(istart, clb_index,
+            int high_fanout_threshold = helper_ctx.high_fanout_thresholds.get_threshold(helper_ctx.cluster_type[legalization_cluster_id]->name);
+            update_cluster_stats(istart,
                                  is_clock,  //Set of clock nets
                                  is_global, //Set of global nets (currently all clocks)
                                  packer_opts.global_clocks,
@@ -288,9 +281,9 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                  *is only one atom block clustered it would not change anything      */
             }
             // FIXME: This access should be a getter.
-            cur_cluster_placement_stats_ptr = &(helper_ctx.cluster_legalizer.cluster_placement_stats[cluster_ctx.clb_nlist.block_type(clb_index)->index]);
+            cur_cluster_placement_stats_ptr = &(helper_ctx.cluster_legalizer.cluster_placement_stats[helper_ctx.cluster_type[legalization_cluster_id]->index]);
             cluster_stats.num_unrelated_clustering_attempts = 0;
-            next_molecule = get_molecule_for_cluster(cluster_ctx.clb_nlist.block_pb(clb_index),
+            next_molecule = get_molecule_for_cluster(helper_ctx.cluster_pb[legalization_cluster_id],
                                                      attraction_groups,
                                                      allow_unrelated_clustering,
                                                      packer_opts.prioritize_transitive_connectivity,
@@ -299,7 +292,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                      &cluster_stats.num_unrelated_clustering_attempts,
                                                      cur_cluster_placement_stats_ptr,
                                                      clb_inter_blk_nets,
-                                                     clb_index,
+                                                     legalization_cluster_id,
                                                      verbosity,
                                                      clustering_data.unclustered_list_head,
                                                      unclustered_list_head_size,
@@ -333,7 +326,6 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                  num_repeated_molecules,
                                  cluster_stats,
                                  helper_ctx.total_clb_num,
-                                 clb_index,
                                  legalization_cluster_id,
                                  attraction_groups,
                                  clb_inter_blk_nets,
@@ -361,10 +353,11 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
             }
 
             if (is_cluster_legal) {
+                // helper_ctx.legalized_clusters.push_back(legalization_cluster_id);
                 istart = save_cluster_routing_and_pick_new_seed(packer_opts, seed_atoms, num_blocks_hill_added, seed_index, cluster_stats);
-                store_cluster_info_and_free(packer_opts, clb_index, logic_block_type, le_pb_type, le_count, clb_inter_blk_nets);
+                store_cluster_info_and_free(packer_opts, legalization_cluster_id, logic_block_type, le_pb_type, le_count, clb_inter_blk_nets);
             } else {
-                free_data_and_requeue_used_mols_if_illegal(clb_index, legalization_cluster_id, saved_seed_index, num_used_type_instances, helper_ctx.total_clb_num, seed_index);
+                free_data_and_requeue_used_mols_if_illegal(legalization_cluster_id, saved_seed_index, num_used_type_instances, helper_ctx.total_clb_num, seed_index);
             }
         }
     }

vpr/src/pack/cluster.h

@@ -22,10 +22,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                          bool balance_block_type_utilization,
                                                          AttractionInfo& attraction_groups,
                                                          bool& floorplan_regions_overfull,
-                                                         t_clustering_data& clustering_data,
-                                                         size_t num_models);
-
-int get_cluster_of_block(int blkidx);
+                                                         t_clustering_data& clustering_data);
 
 void print_pb_type_count(const ClusteredNetlist& clb_nlist);
 #endif

vpr/src/pack/cluster_legalizer.cpp

@@ -16,10 +16,12 @@
 #include <tuple>
 #include <vector>
 #include "atom_lookup.h"
+#include "atom_netlist.h"
 #include "cluster_placement.h"
 #include "cluster_router.h"
 #include "globals.h"
 #include "logic_types.h"
+#include "netlist_utils.h"
 #include "noc_data_types.h"
 #include "pack_types.h"
 #include "partition.h"
@@ -514,15 +516,13 @@ try_place_atom_block_rec(const t_pb_graph_node* pb_graph_node,
         // FIXME: UPDATE THIS!
         VTR_ASSERT(!atom_ctx.lookup.pb_atom(pb)
                    && atom_ctx.lookup.atom_pb(blk_id) == nullptr
-                   && (!atom_cluster.contains(blk_id) ||
-                       atom_cluster[blk_id] == LegalizationClusterId::INVALID()));
+                   && atom_cluster[blk_id] == LegalizationClusterId::INVALID());
         /* try pack to location */
         VTR_ASSERT(pb->name == nullptr);
         pb->name = vtr::strdup(atom_ctx.nlist.block_name(blk_id).c_str());
 
         //Update the atom netlist mappings
-        // FIXME: This needs to be cleaned up!
-        atom_cluster.insert(blk_id, cluster_id);
+        atom_cluster[blk_id] = cluster_id;
         // NOTE: This pb is different from the pb of the cluster. It is the pb
         //       of the actual primitive. It may be an upwards battle to try and
         //       remove it!
@@ -679,10 +679,8 @@ static void compute_and_mark_lookahead_pins_used_for_pin(const t_pb_graph_pin* p
             // pb_graph_pin driving net_id in the driver pb block
             t_pb_graph_pin* output_pb_graph_pin = nullptr;
             // if the driver block is in the same clb as the input primitive block
-            // FIXME: If atom_cluster was a vector, this can be made much cleaner!
-            LegalizationClusterId driver_cluster_id = atom_cluster.contains(driver_blk_id) ? atom_cluster[driver_blk_id] : LegalizationClusterId::INVALID();
-            LegalizationClusterId prim_cluster_id = atom_cluster.contains(prim_blk_id) ? atom_cluster[prim_blk_id] : LegalizationClusterId::INVALID();
-            // if (atom_ctx.lookup.atom_clb(driver_blk_id) == atom_ctx.lookup.atom_clb(prim_blk_id)) {
+            LegalizationClusterId driver_cluster_id = atom_cluster[driver_blk_id];
+            LegalizationClusterId prim_cluster_id = atom_cluster[prim_blk_id];
             if (driver_cluster_id == prim_cluster_id) {
                 // get pb_graph_pin driving the given net
                 output_pb_graph_pin = get_driver_pb_graph_pin(driver_pb, driver_pin_id);
@@ -753,9 +751,7 @@ static void compute_and_mark_lookahead_pins_used_for_pin(const t_pb_graph_pin* p
                 LegalizationClusterId driver_cluster = atom_cluster[driver_blk_id];
                 for (auto pin_id : atom_ctx.nlist.net_sinks(net_id)) {
                     auto sink_blk_id = atom_ctx.nlist.pin_block(pin_id);
-                    // FIXME: Can be made cleaner if atom_cluster was a vector
-                    if (!atom_cluster.contains(sink_blk_id) ||
-                         atom_cluster[sink_blk_id] != driver_cluster) {
+                    if (atom_cluster[sink_blk_id] != driver_cluster) {
                         all_sinks_in_cur_cluster = false;
                         break;
                     }
@@ -1320,6 +1316,10 @@ e_block_pack_status ClusterLegalizer::try_pack_molecule(t_pack_molecule* molecul
                     cur_molecule->valid = false;
 
                     commit_primitive(cluster_placement_stats_ptr, primitives_list[i]);
+
+                    // FIXME: Does this need to go here? Shouldn't all atoms
+                    //        be labeled?
+                    atom_cluster[atom_blk_id] = cluster_id;
                 }
 
                 // Update the lookahead pins used.
@@ -1399,13 +1399,14 @@ ClusterLegalizer::start_new_cluster(t_pack_molecule* molecule,
     // TODO: Figure out why this uses FULL_EXTERNAL_PIN_UTIL
     //Constant allowing all cluster pins to be used
     const t_ext_pin_util FULL_EXTERNAL_PIN_UTIL(1., 1.);
-    LegalizationClusterId new_cluster_id = LegalizationClusterId(legalization_clusters.size());
+    LegalizationClusterId new_cluster_id = LegalizationClusterId(legalization_cluster_ids.size());
     e_block_pack_status pack_status = try_pack_molecule(molecule,
                                                         new_cluster,
                                                         new_cluster_id,
                                                         FULL_EXTERNAL_PIN_UTIL);
 
     if (pack_status == e_block_pack_status::BLK_PASSED) {
+        legalization_cluster_ids.push_back(new_cluster_id);
         legalization_clusters.push_back(std::move(new_cluster));
         molecule_cluster[molecule] = new_cluster_id;
     } else {
@@ -1467,6 +1468,8 @@ void ClusterLegalizer::destroy_cluster(LegalizationClusterId cluster_id) {
         VTR_ASSERT_SAFE(molecule_cluster.find(mol) != molecule_cluster.end() &&
                         molecule_cluster[mol] == cluster_id);
         molecule_cluster[mol] = LegalizationClusterId::INVALID();
+        // FIXME: Document this.
+        mol->valid = true;
         // Revert the placement of all blocks in the molecule.
         // TODO: remove_atom_from_target can also be used for a move function
         //       to remove a single molecule from a cluster. Truly just copy
@@ -1490,6 +1493,35 @@ void ClusterLegalizer::destroy_cluster(LegalizationClusterId cluster_id) {
     free_router_data(cluster.router_data);
     cluster.router_data = nullptr;
     cluster.pr = PartitionRegion();
+
+    // Mark the cluster as invalid.
+    legalization_cluster_ids[cluster_id] = LegalizationClusterId::INVALID();
+}
+
+void ClusterLegalizer::compress() {
+    // Create a map from the old ids to the new (compressed) one.
+    vtr::vector_map<LegalizationClusterId, LegalizationClusterId> cluster_id_map;
+    cluster_id_map = compress_ids(legalization_cluster_ids);
+    // Update all cluster values.
+    legalization_cluster_ids = clean_and_reorder_ids(cluster_id_map);
+    legalization_clusters = clean_and_reorder_values(legalization_clusters, cluster_id_map);
+    // Update the reverse lookups.
+    for (auto& it : molecule_cluster) {
+        if (!it.second.is_valid())
+            continue;
+        molecule_cluster[it.first] = cluster_id_map[it.second];
+    }
+    for (size_t i = 0; i < atom_cluster.size(); i++) {
+        AtomBlockId atom_blk_id = AtomBlockId(i);
+        LegalizationClusterId old_cluster_id = atom_cluster[atom_blk_id];
+        if (!old_cluster_id.is_valid())
+            continue;
+        atom_cluster[atom_blk_id] = cluster_id_map[old_cluster_id];
+    }
+    // Shrink everything to fit
+    legalization_cluster_ids.shrink_to_fit();
+    legalization_clusters.shrink_to_fit();
+    atom_cluster.shrink_to_fit();
 }
 
 bool ClusterLegalizer::check_cluster_legality(LegalizationClusterId cluster_id) {
@@ -1498,7 +1530,8 @@ bool ClusterLegalizer::check_cluster_legality(LegalizationClusterId cluster_id)
     return try_intra_lb_route(cluster.router_data, log_verbosity, &mode_status);
 }
 
-void ClusterLegalizer::init(const Prepacker& prepacker,
+void ClusterLegalizer::init(const AtomNetlist& atom_netlist,
+                            const Prepacker& prepacker,
                             const std::vector<t_logical_block_type>& logical_block_types,
                             std::vector<t_lb_type_rr_node>* t_lb_type_rr_graphs,
                             size_t t_num_models,
@@ -1514,6 +1547,8 @@ void ClusterLegalizer::init(const Prepacker& prepacker,
     // Verify that the inputs are valid.
     VTR_ASSERT(t_lb_type_rr_graphs != nullptr);
 
+    // Resize the atom_cluster lookup to make the accesses much cheaper.
+    atom_cluster.resize(atom_netlist.blocks().size(), LegalizationClusterId::INVALID());
     // Allocate the cluster_placement_stats
     cluster_placement_stats = alloc_and_load_cluster_placement_stats();
     // Allocate the primitives_lists