[SQUASH ME] Added a clean method to save memory during packing.

Author: AlexandreSinger

vpr/src/pack/cluster.cpp

@@ -360,6 +360,10 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                     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);
+                // Since the cluster will no longer be added to beyond this point,
+                // clean the cluster of any data not strictly necessary for
+                // creating the clustered netlist.
+                cluster_legalizer.clean_cluster(legalization_cluster_id);
             } else {
                 // If the cluster is not legal, requeue used mols.
                 num_used_type_instances[cluster_legalizer.get_cluster_type(legalization_cluster_id)]--;

vpr/src/pack/cluster_legalizer.cpp

@@ -19,6 +19,7 @@
 #include "atom_netlist.h"
 #include "cluster_placement.h"
 #include "cluster_router.h"
+#include "cluster_util.h"
 #include "globals.h"
 #include "logic_types.h"
 #include "netlist_utils.h"
@@ -139,6 +140,26 @@ static void check_cluster_atom_blocks(t_pb* pb, std::unordered_set<AtomBlockId>&
     }
 }
 
+/// @brief Recursively frees the pb stats of the given pb, without freeing the
+///        pb itself.
+static void free_pb_stats_recursive(t_pb* pb) {
+    /* Releases all the memory used by clustering data structures.   */
+    if (pb) {
+        if (pb->pb_graph_node != nullptr) {
+            if (!pb->pb_graph_node->is_primitive()) {
+                for (int i = 0; i < pb->pb_graph_node->pb_type->modes[pb->mode].num_pb_type_children; i++) {
+                    for (int j = 0; j < pb->pb_graph_node->pb_type->modes[pb->mode].pb_type_children[i].num_pb; j++) {
+                        if (pb->child_pbs && pb->child_pbs[i]) {
+                            free_pb_stats_recursive(&pb->child_pbs[i][j]);
+                        }
+                    }
+                }
+            }
+        }
+        free_pb_stats(pb);
+    }
+}
+
 /* 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. */
@@ -1468,6 +1489,7 @@ e_block_pack_status ClusterLegalizer::add_mol_to_cluster(t_pack_molecule* molecu
 
     // Get the cluster.
     LegalizationCluster& cluster = legalization_clusters[cluster_id];
+    VTR_ASSERT(cluster.router_data != nullptr && "Cannot add molecule to cleaned cluster!");
     // Set the target_external_pin_util.
     t_ext_pin_util target_ext_pin_util = target_external_pin_util.get_pin_util(cluster.type->name);
     // Try to pack the molecule into the cluster.
@@ -1548,9 +1570,26 @@ void ClusterLegalizer::compress() {
     atom_cluster.shrink_to_fit();
 }
 
+void ClusterLegalizer::clean_cluster(LegalizationClusterId cluster_id) {
+    // Safety asserts to make sure the inputs are valid.
+    VTR_ASSERT_SAFE(cluster_id.is_valid() && (size_t)cluster_id < legalization_clusters.size());
+    // Get the cluster.
+    LegalizationCluster& cluster = legalization_clusters[cluster_id];
+    // Free the pb stats.
+    free_pb_stats_recursive(cluster.pb);
+    // Load the pb_route so we can free the cluster router data.
+    // The pb_route is used when creating a netlist from the legalized clusters.
+    std::vector<t_intra_lb_net>* saved_lb_nets = cluster.router_data->saved_lb_nets;
+    t_pb_graph_node* pb_graph_node = cluster.pb->pb_graph_node;
+    cluster.pb->pb_route = alloc_and_load_pb_route(saved_lb_nets, pb_graph_node);
+    // Free the router data.
+    free_router_data(cluster.router_data);
+    cluster.router_data = nullptr;
+}
+
 bool ClusterLegalizer::check_cluster_legality(LegalizationClusterId cluster_id) {
     // Safety asserts to make sure the inputs are valid.
-    VTR_ASSERT_DEBUG(cluster_id.is_valid() && (size_t)cluster_id < legalization_clusters.size());
+    VTR_ASSERT_SAFE(cluster_id.is_valid() && (size_t)cluster_id < legalization_clusters.size());
     // To check if a cluster is fully legal, try to perform an intra logic block
     // route on the cluster. If it succeeds, the cluster is fully legal.
     t_mode_selection_status mode_status;
@@ -1616,8 +1655,6 @@ void ClusterLegalizer::reset() {
     // Reset the molecule_cluster map
     molecule_cluster.clear();
     // Reset the cluster placement stats.
-    // FIXME: Is this necessary? Or is there a way to clear the cluster placement
-    //        stats?
     free_cluster_placement_stats(cluster_placement_stats);
     cluster_placement_stats = alloc_and_load_cluster_placement_stats();
 }
@@ -1692,12 +1729,11 @@ void ClusterLegalizer::finalize() {
     for (LegalizationClusterId cluster_id : legalization_cluster_ids) {
         if (!cluster_id.is_valid())
             continue;
-        LegalizationCluster& cluster = legalization_clusters[cluster_id];
-        t_pb* cluster_pb = cluster.pb;
-        t_lb_router_data* cluster_router_data = cluster.router_data;
-        std::vector<t_intra_lb_net>* saved_lb_nets = cluster_router_data->saved_lb_nets;
-        t_pb_graph_node* pb_graph_node = cluster_pb->pb_graph_node;
-        cluster_pb->pb_route = alloc_and_load_pb_route(saved_lb_nets, pb_graph_node);
+        // If the cluster has not already been cleaned, clean it. This will
+        // generate the pb_route necessary for generating a clustered netlist.
+        const LegalizationCluster& cluster = legalization_clusters[cluster_id];
+        if (cluster.router_data != nullptr)
+            clean_cluster(cluster_id);
     }
 }
 

vpr/src/pack/cluster_legalizer.h

@@ -265,12 +265,22 @@ class ClusterLegalizer {
      */
     bool check_cluster_legality(LegalizationClusterId cluster_id);
 
-    // 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.
+    /*
+     * @brief Cleans the cluster of unnessary data, reducing the memory footprint.
+     *
+     * After this function is called, no more molecules can be added to the
+     * cluster. This will ensure that the cluster has enough information to
+     * generate a clustered netlist from the legalized clusters.
+     *
+     * Specifically, this frees the pb stats (which is used by the clusterer
+     * to compute the gain) and the router data of the cluster.
+     *
+     * TODO: The pb stats should really not be calculated or stored in the
+     *       cluster legalizer.
+     *
+     *  @param cluster_id   The ID of the cluster to clean.
+     */
+    void clean_cluster(LegalizationClusterId cluster_id);
 
     /*
      * @brief Verify that all atoms have been clustered into a cluster.

vpr/src/pack/cluster_util.cpp

@@ -398,26 +398,6 @@ void alloc_and_init_clustering(const t_molecule_stats& max_molecule_stats,
 
 /*****************************************/
 
-void free_pb_stats_recursive(t_pb* pb) {
-    int i, j;
-    /* Releases all the memory used by clustering data structures.   */
-    if (pb) {
-        if (pb->pb_graph_node != nullptr) {
-            if (!pb->pb_graph_node->is_primitive()) {
-                for (i = 0; i < pb->pb_graph_node->pb_type->modes[pb->mode].num_pb_type_children; i++) {
-                    for (j = 0; j < pb->pb_graph_node->pb_type->modes[pb->mode].pb_type_children[i].num_pb; j++) {
-                        if (pb->child_pbs && pb->child_pbs[i]) {
-                            free_pb_stats_recursive(&pb->child_pbs[i][j]);
-                        }
-                    }
-                }
-            }
-        }
-        free_pb_stats(pb);
-    }
-}
-
-/*****************************************/
 t_pack_molecule* get_molecule_by_num_ext_inputs(const int ext_inps,
                                                 const enum e_removal_policy remove_flag,
                                                 t_cluster_placement_stats* cluster_placement_stats_ptr,

vpr/src/pack/cluster_util.h

@@ -133,8 +133,6 @@ void alloc_and_init_clustering(const t_molecule_stats& max_molecule_stats,
                                int& unclustered_list_head_size,
                                int num_molecules);
 
-void free_pb_stats_recursive(t_pb* pb);
-
 t_pack_molecule* get_molecule_by_num_ext_inputs(const int ext_inps,
                                                 const enum e_removal_policy remove_flag,
                                                 t_cluster_placement_stats* cluster_placement_stats_ptr,