[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!)

Author: AlexandreSinger

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"
@@ -613,12 +614,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);
 
@@ -685,8 +687,7 @@ bool vpr_pack(t_vpr_setup& vpr_setup, const t_arch& arch) {
 
     return try_pack(&vpr_setup.PackerOpts, &vpr_setup.AnalysisOpts,
                     &arch, vpr_setup.user_models,
-                    vpr_setup.library_models, inter_cluster_delay,
-                    vpr_setup.PackerRRGraph);
+                    vpr_setup.library_models, inter_cluster_delay);
 }
 
 void vpr_load_packing(t_vpr_setup& vpr_setup, const t_arch& arch) {
@@ -696,6 +697,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 +708,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
 
@@ -83,6 +84,7 @@ struct AtomContext : public Context {
     ///        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.
+    /// FIXME: Move this to the clustering helper context. It makes more sense there.
     Prepacker prepacker;
 };
 
@@ -298,6 +300,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;
+
+    // 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;
 };
 
 /**
@@ -308,47 +315,10 @@ struct ClusteringContext : public Context {
  * 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]
+    // 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;
-
-    // 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
-    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;
-    }
 };
 
 /**

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)