[ClusterLegalizer] Cluster Legalizer API

Isolated the cluster legalization logic out of the packer's clustering
algorithm in such a way that it can be used externally to the clusterer
with no issue. Once the ClusterLegalizer API is constructed, it will
allocate all of the memory that it needs for legalization; it can then
be used to legalize clusters; and when it is destroyed it will remove
all state created for clustering.

The cluster legalizer API maintains the legalized clusters internally as
opposed to using the ClusterBlockId as an ID to the clusters. This
allowed me to separate the ClusteredNetlist from the packing algorithm
entirely. This importantly helper separate out all legalization logic
from directly modifying the ClusteredNetlist generation code.

I did my best to remove as much global state as I could from the API to
make it as self-contained as possible.

This change greatly cleaned up the packer code and removed many of its
global variables (including the ClusterLegalizer itself, which is now a
local variable!)

This change also removed the re_clustering API since it would need to be
heavily modified to include this change; and since this feature was not
being tested, it would be challenging to upgrade to use this new cluster
legalization API.

Author: AlexandreSinger

vpr/src/base/SetupGrid.h

@@ -12,6 +12,8 @@
 #include <vector>
 #include "physical_types.h"
 
+class DeviceGrid;
+
 ///@brief Find the device satisfying the specified minimum resources
 /// minimum_instance_counts and target_device_utilization are not required when specifying a fixed layout
 DeviceGrid create_device_grid(const std::string& layout_name,

vpr/src/base/vpr_api.cpp

@@ -15,6 +15,7 @@
 #include <cstring>
 #include <cmath>
 
+#include "vpr_context.h"
 #include "vtr_assert.h"
 #include "vtr_math.h"
 #include "vtr_log.h"
@@ -359,9 +360,7 @@ void vpr_init_with_options(const t_options* options, t_vpr_setup* vpr_setup, t_a
 
     fflush(stdout);
 
-    auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
     auto& device_ctx = g_vpr_ctx.mutable_device();
-    helper_ctx.lb_type_rr_graphs = vpr_setup->PackerRRGraph;
     device_ctx.pad_loc_type = vpr_setup->PlacerOpts.pad_loc_type;
 }
 
@@ -613,12 +612,13 @@ bool vpr_pack_flow(t_vpr_setup& vpr_setup, const t_arch& arch) {
                 //Load a previous packing from the .net file
                 vpr_load_packing(vpr_setup, arch);
 
-                //Load cluster_constraints data structure here since loading pack file
-                load_cluster_constraints();
             }
 
         }
 
+        // Load cluster_constraints data structure here since loading pack file
+        load_cluster_constraints();
+
         /* Sanity check the resulting netlist */
         check_netlist(packer_opts.pack_verbosity);
 
@@ -696,6 +696,7 @@ void vpr_load_packing(t_vpr_setup& vpr_setup, const t_arch& arch) {
                    "Must have valid .net filename to load packing");
 
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     /* Ensure we have a clean start with void net remapping information */
     cluster_ctx.post_routing_clb_pin_nets.clear();
@@ -706,8 +707,15 @@ void vpr_load_packing(t_vpr_setup& vpr_setup, const t_arch& arch) {
                                          vpr_setup.FileNameOpts.verify_file_digests,
                                          vpr_setup.PackerOpts.pack_verbosity);
 
+    /* Load the mapping between clusters and their atoms */
+    cluster_ctx.atoms_lookup.resize(cluster_ctx.clb_nlist.blocks().size());
+    for (AtomBlockId atom_blk_id : atom_ctx.nlist.blocks()) {
+        ClusterBlockId atom_cluster_blk_id = atom_ctx.lookup.atom_clb(atom_blk_id);
+        cluster_ctx.atoms_lookup[atom_cluster_blk_id].insert(atom_blk_id);
+    }
+
     process_constant_nets(g_vpr_ctx.mutable_atom().nlist,
-                          g_vpr_ctx.atom().lookup,
+                          atom_ctx.lookup,
                           cluster_ctx.clb_nlist,
                           vpr_setup.constant_net_method,
                           vpr_setup.PackerOpts.pack_verbosity);

vpr/src/base/vpr_constraints_writer.cpp

@@ -7,17 +7,15 @@
 #include "vpr_constraints_serializer.h"
 #include "vpr_constraints_uxsdcxx.h"
 
-#include "vtr_time.h"
+#include "vpr_context.h"
 
 #include "globals.h"
 #include "pugixml.hpp"
-#include "pugixml_util.hpp"
-#include "clustered_netlist_utils.h"
 
 #include <fstream>
+#include <unordered_set>
 #include "vpr_constraints_writer.h"
 #include "region.h"
-#include "re_cluster_util.h"
 
 /**
  * @brief Create a partition with the given name and a single region.
@@ -30,7 +28,6 @@ static Partition create_partition(const std::string& part_name, const Region& re
 
 void write_vpr_floorplan_constraints(const char* file_name, int expand, bool subtile, int horizontal_partitions, int vertical_partitions) {
     VprConstraints constraints;
-
     if (horizontal_partitions != 0 && vertical_partitions != 0) {
         setup_vpr_floorplan_constraints_cutpoints(constraints, horizontal_partitions, vertical_partitions);
     } else {
@@ -83,16 +80,17 @@ void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints, int ex
         part.set_part_region(pr);
         constraints.mutable_place_constraints().add_partition(part);
 
-        const std::unordered_set<AtomBlockId>& atoms = cluster_to_atoms(blk_id);
-
+        const std::unordered_set<AtomBlockId>& atoms = cluster_ctx.atoms_lookup[blk_id];
         for (AtomBlockId atom_id : atoms) {
             constraints.mutable_place_constraints().add_constrained_atom(atom_id, partid);
         }
         part_id++;
     }
 }
 
-void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints, int horizontal_cutpoints, int vertical_cutpoints) {
+void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints,
+                                               int horizontal_cutpoints,
+                                               int vertical_cutpoints) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& block_locs = g_vpr_ctx.placement().block_locs();
     auto& device_ctx = g_vpr_ctx.device();
@@ -158,7 +156,7 @@ void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints, int
      * appropriate region accordingly
      */
     for (ClusterBlockId blk_id : cluster_ctx.clb_nlist.blocks()) {
-        const std::unordered_set<AtomBlockId>& atoms = cluster_to_atoms(blk_id);
+        const std::unordered_set<AtomBlockId>& atoms = cluster_ctx.atoms_lookup[blk_id];
         int x = block_locs[blk_id].loc.x;
         int y = block_locs[blk_id].loc.y;
         int width = device_ctx.grid.width();

vpr/src/base/vpr_constraints_writer.h

@@ -25,6 +25,8 @@
 #ifndef VPR_SRC_BASE_VPR_CONSTRAINTS_WRITER_H_
 #define VPR_SRC_BASE_VPR_CONSTRAINTS_WRITER_H_
 
+class VprConstraints;
+
 /**
  * @brief Write out floorplan constraints to an XML file based on current placement
  *

vpr/src/base/vpr_context.h

@@ -35,6 +35,7 @@
 #include "noc_routing.h"
 #include "tatum/report/TimingPath.hpp"
 #include "blk_loc_registry.h"
+#include "vtr_vector_map.h"
 
 #ifndef NO_SERVER
 
@@ -78,12 +79,6 @@ struct AtomContext : public Context {
 
     /// @brief Mappings to/from the Atom Netlist to physically described .blif models
     AtomLookup lookup;
-
-    /// @brief Prepacker object which performs prepacking and stores the pack
-    ///        molecules. Has a method to get the pack molecule of an AtomBlock.
-    /// TODO: This is mainly only used in the clusterer. It can probably be
-    ///       removed from the AtomContext entirely.
-    Prepacker prepacker;
 };
 
 /**
@@ -298,57 +293,11 @@ struct ClusteringContext : public Context {
      */
     std::map<ClusterBlockId, std::map<int, ClusterNetId>> post_routing_clb_pin_nets;
     std::map<ClusterBlockId, std::map<int, int>> pre_routing_net_pin_mapping;
-};
-
-/**
- * @brief State relating to helper data structure using in the clustering stage
- *
- * This should contain helper data structures that are useful in the clustering/packing stage.
- * They are encapsulated here as they are useful in clustering and reclustering algorithms that may be used
- * in packing or placement stages.
- */
-struct ClusteringHelperContext : public Context {
-    // A map used to save the number of used instances from each logical block type.
-    std::map<t_logical_block_type_ptr, size_t> num_used_type_instances;
-
-    // Stats keeper for placement information during packing/clustering
-    t_cluster_placement_stats* cluster_placement_stats;
-
-    // total number of models in the architecture
-    int num_models;
-
-    int max_cluster_size;
-    t_pb_graph_node** primitives_list;
-
-    bool enable_pin_feasibility_filter;
-    int feasible_block_array_size;
 
-    // total number of CLBs
-    int total_clb_num;
-
-    // A vector of routing resource nodes within each of logic cluster_ctx.blocks types [0 .. num_logical_block_type-1]
-    std::vector<t_lb_type_rr_node>* lb_type_rr_graphs;
-
-    // the utilization of external input/output pins during packing (between 0 and 1)
-    t_ext_pin_util_targets target_external_pin_util;
-
-    // During clustering, a block is related to un-clustered primitives with nets.
-    // This relation has three types: low fanout, high fanout, and transitive
-    // high_fanout_thresholds stores the threshold for nets to a block type to be considered high fanout
-    t_pack_high_fanout_thresholds high_fanout_thresholds;
-
-    // A vector of unordered_sets of AtomBlockIds that are inside each clustered block [0 .. num_clustered_blocks-1]
-    // unordered_set for faster insertion/deletion during the iterative improvement process of packing
+    // A vector of unordered_sets of AtomBlockIds that are inside each clustered
+    // block [0 .. num_clustered_blocks-1]
+    // This is populated when the packing is loaded.
     vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>> atoms_lookup;
-
-    /** Stores the NoC group ID of each atom block. Atom blocks that belong
-     * to different NoC groups can't be clustered with each other into the
-     * same clustered block.*/
-    vtr::vector<AtomBlockId, NocGroupId> atom_noc_grp_id;
-
-    ~ClusteringHelperContext() {
-        delete[] primitives_list;
-    }
 };
 
 /**
@@ -728,9 +677,6 @@ class VprContext : public Context {
     const ClusteringContext& clustering() const { return clustering_; }
     ClusteringContext& mutable_clustering() { return clustering_; }
 
-    const ClusteringHelperContext& cl_helper() const { return helper_; }
-    ClusteringHelperContext& mutable_cl_helper() { return helper_; }
-
     const PlacementContext& placement() const { return placement_; }
     PlacementContext& mutable_placement() { return placement_; }
 
@@ -760,8 +706,6 @@ class VprContext : public Context {
     PowerContext power_;
 
     ClusteringContext clustering_;
-    ClusteringHelperContext helper_;
-
     PlacementContext placement_;
     RoutingContext routing_;
     FloorplanningContext constraints_;

vpr/src/base/vpr_types.h

@@ -168,15 +168,6 @@ enum class e_cluster_seed {
     BLEND2
 };
 
-enum class e_block_pack_status {
-    BLK_PASSED,
-    BLK_FAILED_FEASIBLE,
-    BLK_FAILED_ROUTE,
-    BLK_FAILED_FLOORPLANNING,
-    BLK_FAILED_NOC_GROUP,
-    BLK_STATUS_UNDEFINED
-};
-
 struct t_ext_pin_util {
     t_ext_pin_util() = default;
     t_ext_pin_util(float in, float out)