[SQUASH ME] Cleaned up cluster_utils.

Author: AlexandreSinger

vpr/src/base/vpr_context.h

@@ -315,7 +315,7 @@ struct ClusteringContext : public Context {
  * in packing or placement stages.
  */
 struct ClusteringHelperContext : public Context {
-    // A vector of routing resource nodes within each of logic cluster_ctx.blocks types [0 .. num_logical_block_type-1]
+    // A vector of routing resource nodes within each of logic cluster_ctx.blocks types [1 .. 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.
     std::vector<t_lb_type_rr_node>* lb_type_rr_graphs;

vpr/src/pack/cluster.cpp

@@ -342,10 +342,21 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
             }
 
             if (is_cluster_legal) {
-                istart = save_cluster_routing_and_pick_new_seed(packer_opts, seed_atoms, cluster_legalizer, num_blocks_hill_added, seed_index, cluster_stats);
+                // Pick new seed.
+                istart = get_highest_gain_seed_molecule(seed_index, seed_atoms, cluster_legalizer);
+                // Update cluster stats.
+                if (packer_opts.timing_driven && num_blocks_hill_added > 0)
+                    cluster_stats.blocks_since_last_analysis += num_blocks_hill_added;
+
                 store_cluster_info_and_free(packer_opts, legalization_cluster_id, logic_block_type, le_pb_type, le_count, cluster_legalizer, clb_inter_blk_nets);
             } else {
-                free_data_and_requeue_used_mols_if_illegal(legalization_cluster_id, cluster_legalizer, saved_seed_index, num_used_type_instances, total_clb_num, seed_index);
+                // If the cluster is not legal, requeue used mols.
+                num_used_type_instances[cluster_legalizer.get_cluster_type(legalization_cluster_id)]--;
+                total_clb_num--;
+                seed_index = saved_seed_index;
+                // Destroy the illegal cluster.
+                cluster_legalizer.destroy_cluster(legalization_cluster_id);
+                cluster_legalizer.compress();
             }
         }
     }

vpr/src/pack/cluster_legalizer.cpp

@@ -96,6 +96,49 @@ static void alloc_and_load_pb_stats(t_pb* pb, const int feasible_block_array_siz
     pb->pb_stats->explore_transitive_fanout = true;
 }
 
+/*
+ * @brief Check the atom blocks of a cluster pb. Used in the verify method.
+ */
+/* TODO: May want to check that all atom blocks are actually reached */
+static void check_cluster_atom_blocks(t_pb* pb, std::unordered_set<AtomBlockId>& blocks_checked) {
+    int i, j;
+    const t_pb_type* pb_type;
+    bool has_child = false;
+    auto& atom_ctx = g_vpr_ctx.atom();
+
+    pb_type = pb->pb_graph_node->pb_type;
+    if (pb_type->num_modes == 0) {
+        /* primitive */
+        auto blk_id = atom_ctx.lookup.pb_atom(pb);
+        if (blk_id) {
+            if (blocks_checked.count(blk_id)) {
+                VPR_FATAL_ERROR(VPR_ERROR_PACK,
+                                "pb %s contains atom block %s but atom block is already contained in another pb.\n",
+                                pb->name, atom_ctx.nlist.block_name(blk_id).c_str());
+            }
+            blocks_checked.insert(blk_id);
+            if (pb != atom_ctx.lookup.atom_pb(blk_id)) {
+                VPR_FATAL_ERROR(VPR_ERROR_PACK,
+                                "pb %s contains atom block %s but atom block does not link to pb.\n",
+                                pb->name, atom_ctx.nlist.block_name(blk_id).c_str());
+            }
+        }
+    } else {
+        /* this is a container pb, all container pbs must contain children */
+        for (i = 0; i < pb_type->modes[pb->mode].num_pb_type_children; i++) {
+            for (j = 0; j < pb_type->modes[pb->mode].pb_type_children[i].num_pb; j++) {
+                if (pb->child_pbs[i] != nullptr) {
+                    if (pb->child_pbs[i][j].name != nullptr) {
+                        has_child = true;
+                        check_cluster_atom_blocks(&pb->child_pbs[i][j], blocks_checked);
+                    }
+                }
+            }
+        }
+        VTR_ASSERT(has_child);
+    }
+}
+
 /* Record the failure of the molecule in this cluster in the current pb stats.
  * If a molecule fails repeatedly, it's gain will be penalized if packing with
  * attraction groups on. */
@@ -1350,6 +1393,8 @@ ClusterLegalizer::start_new_cluster(t_pack_molecule* molecule,
                     primitives_list != nullptr &&
                     lb_type_rr_graphs != nullptr);
 
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
+
     // Create the physical block for this cluster based on the type.
     t_pb* cluster_pb = new t_pb;
     cluster_pb->pb_graph_node = cluster_type->pb_graph_head;
@@ -1385,8 +1430,17 @@ ClusterLegalizer::start_new_cluster(t_pack_molecule* molecule,
                                                         FULL_EXTERNAL_PIN_UTIL);
 
     if (pack_status == e_block_pack_status::BLK_PASSED) {
+        // Give the new cluster pb a name. The current convention is to name the
+        // cluster after the root atom of the first molecule packed into it.
+        AtomBlockId root_atom = molecule->atom_block_ids[molecule->root];
+        const std::string& root_atom_name = atom_ctx.nlist.block_name(root_atom);
+        if (new_cluster.pb->name != nullptr)
+            free(new_cluster.pb->name);
+        new_cluster.pb->name = vtr::strdup(root_atom_name.c_str());
+        // Move the cluster into the vector of clusters and ids.
         legalization_cluster_ids.push_back(new_cluster_id);
         legalization_clusters.push_back(std::move(new_cluster));
+        // Update the molecule to cluster map.
         molecule_cluster[molecule] = new_cluster_id;
     } else {
         // Delete the new_cluster.
@@ -1578,6 +1632,72 @@ void ClusterLegalizer::reset() {
     cluster_placement_stats = alloc_and_load_cluster_placement_stats();
 }
 
+void ClusterLegalizer::verify() {
+    std::unordered_set<AtomBlockId> atoms_checked;
+    auto& atom_ctx = g_vpr_ctx.atom();
+
+    if (clusters().size() == 0) {
+        VTR_LOG_WARN("Packing produced no clustered blocks");
+    }
+
+    /*
+     * Check that each atom block connects to one physical primitive and that the primitive links up to the parent clb
+     */
+    for (auto blk_id : atom_ctx.nlist.blocks()) {
+        //Each atom should be part of a pb
+        const t_pb* atom_pb = atom_ctx.lookup.atom_pb(blk_id);
+        if (!atom_pb) {
+            VPR_FATAL_ERROR(VPR_ERROR_PACK,
+                            "Atom block %s is not mapped to a pb\n",
+                            atom_ctx.nlist.block_name(blk_id).c_str());
+        }
+
+        //Check the reverse mapping is consistent
+        if (atom_ctx.lookup.pb_atom(atom_pb) != blk_id) {
+            VPR_FATAL_ERROR(VPR_ERROR_PACK,
+                            "pb %s does not contain atom block %s but atom block %s maps to pb.\n",
+                            atom_pb->name,
+                            atom_ctx.nlist.block_name(blk_id).c_str(),
+                            atom_ctx.nlist.block_name(blk_id).c_str());
+        }
+
+        VTR_ASSERT(atom_ctx.nlist.block_name(blk_id) == atom_pb->name);
+
+        const t_pb* cur_pb = atom_pb;
+        while (cur_pb->parent_pb) {
+            cur_pb = cur_pb->parent_pb;
+            VTR_ASSERT(cur_pb->name);
+        }
+
+        LegalizationClusterId cluster_id = get_atom_cluster(blk_id);
+        if (cluster_id == LegalizationClusterId::INVALID()) {
+            VPR_FATAL_ERROR(VPR_ERROR_PACK,
+                            "Atom %s is not mapped to a CLB\n",
+                            atom_ctx.nlist.block_name(blk_id).c_str());
+        }
+
+        if (cur_pb != get_cluster_pb(cluster_id)) {
+            VPR_FATAL_ERROR(VPR_ERROR_PACK,
+                            "CLB %s does not match CLB contained by pb %s.\n",
+                            cur_pb->name, atom_pb->name);
+        }
+    }
+
+    /* Check that I do not have spurious links in children pbs */
+    for (LegalizationClusterId cluster_id : clusters()) {
+        check_cluster_atom_blocks(get_cluster_pb(cluster_id),
+                                  atoms_checked);
+    }
+
+    for (auto blk_id : atom_ctx.nlist.blocks()) {
+        if (!atoms_checked.count(blk_id)) {
+            VPR_FATAL_ERROR(VPR_ERROR_PACK,
+                            "Atom block %s not found in any cluster.\n",
+                            atom_ctx.nlist.block_name(blk_id).c_str());
+        }
+    }
+}
+
 void ClusterLegalizer::finalize() {
     for (LegalizationClusterId cluster_id : legalization_cluster_ids) {
         if (!cluster_id.is_valid())

vpr/src/pack/cluster_legalizer.h

@@ -233,13 +233,15 @@ class ClusterLegalizer {
         log_verbosity = verbosity;
     }
 
-    // FIXME: We should make a clean method to clean 1 or all clusters.
+    // TODO: Should make a clean method to clean 1 or all clusters.
     //  - free_pb_stats_recursive for example.
     //  - free the router data.
     //  - etc.
     //  - This is to help reduce the memory overhead of the class without
     //    breaking anything.
 
+    void verify();
+
     void finalize();
 
     void reset();