[SQUASH ME] Removed More Global Variables

Author: AlexandreSinger

vpr/src/base/read_netlist.cpp

@@ -10,11 +10,13 @@
 #include <cstring>
 #include <ctime>
 #include <map>
+#include <unordered_set>
 
 #include "pugixml.hpp"
 #include "pugixml_loc.hpp"
 #include "pugixml_util.hpp"
 
+#include "vpr_context.h"
 #include "vtr_assert.h"
 #include "vtr_util.h"
 #include "vtr_log.h"
@@ -75,6 +77,7 @@ ClusteredNetlist read_netlist(const char* net_file,
     std::vector<std::string> circuit_inputs, circuit_outputs, circuit_clocks;
 
     auto& atom_ctx = g_vpr_ctx.mutable_atom();
+    ClusteringHelperContext& mutable_helper_ctx = g_vpr_ctx.mutable_cl_helper();
 
     int num_primitives = 0;
 
@@ -247,6 +250,13 @@ ClusteredNetlist read_netlist(const char* net_file,
     /* load mapping between atom pins and pb_graph_pins */
     load_atom_pin_mapping(clb_nlist);
 
+    /* Load the mapping between clusters and their atoms */
+    mutable_helper_ctx.atoms_lookup.resize(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);
+        mutable_helper_ctx.atoms_lookup[atom_cluster_blk_id].insert(atom_blk_id);
+    }
+
     clock_t end = clock();
 
     VTR_LOG("Finished loading packed FPGA netlist file (took %g seconds).\n", (float)(end - begin) / CLOCKS_PER_SEC);

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,11 +28,14 @@ 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);
+        setup_vpr_floorplan_constraints_cutpoints(constraints,
+                                                  horizontal_partitions,
+                                                  vertical_partitions);
     } else {
-        setup_vpr_floorplan_constraints_one_loc(constraints, expand, subtile);
+        setup_vpr_floorplan_constraints_one_loc(constraints,
+                                                expand,
+                                                subtile);
     }
 
     VprConstraintsSerializer writer(constraints);
@@ -52,9 +53,12 @@ void write_vpr_floorplan_constraints(const char* file_name, int expand, bool sub
     }
 }
 
-void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints, int expand, bool subtile) {
+void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints,
+                                             int expand,
+                                             bool subtile) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& block_locs = g_vpr_ctx.placement().block_locs();
+    const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
 
     int part_id = 0;
     /*
@@ -83,19 +87,21 @@ 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 = helper_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();
+    const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
 
     const int n_layers = device_ctx.grid.get_num_layers();
 
@@ -158,7 +164,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 = helper_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
  *
@@ -50,7 +52,9 @@ void write_vpr_floorplan_constraints(const char* file_name, int expand, bool sub
  *   @param subtile     Specifies whether to write out the constraint regions with or without
  *                      subtile values.
  */
-void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints, int expand, bool subtile);
+void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints,
+                                             int expand,
+                                             bool subtile);
 
 /**
  * @brief Populates VprConstraints by dividing the grid into multiple partitions.
@@ -62,6 +66,8 @@ void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints, int ex
  * @param horizontal_cutpoints The number of horizontal cut-lines.
  * @param vertical_cutpoints The number of vertical cut_lines.
  */
-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);
 
 #endif /* VPR_SRC_BASE_VPR_CONSTRAINTS_WRITER_H_ */

vpr/src/base/vpr_context.h

@@ -325,20 +325,15 @@ struct ClusteringHelperContext : public Context {
     //  - 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.
     std::vector<t_lb_type_rr_node>* lb_type_rr_graphs;
 
     // the utilization of external input/output pins during packing (between 0 and 1)
     // FIXME: This one is weird and may take some work to fix.
+    //  - Putting this in the class and then creating an accessor may fix this
+    //    issue.
     t_ext_pin_util_targets target_external_pin_util;
 
     // During clustering, a block is related to un-clustered primitives with nets.
@@ -347,7 +342,10 @@ struct ClusteringHelperContext : public Context {
     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
+    // FIXME: This should be moved to a better place. It is populated in read
+    //        netlist and used all over the place.
+    //   - Ultimately this information can be read from the legalizer if the
+    //     legalizer can be kept alive for longer.
     vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>> atoms_lookup;
 
     /** Stores the NoC group ID of each atom block. Atom blocks that belong

vpr/src/pack/cluster.cpp

@@ -134,9 +134,6 @@ 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 */
@@ -256,13 +253,13 @@ 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,
-                     helper_ctx.cluster_pb[legalization_cluster_id]->name,
-                     helper_ctx.cluster_type[legalization_cluster_id]->name);
+                     helper_ctx.cluster_legalizer.get_cluster_pb(legalization_cluster_id)->name,
+                     helper_ctx.cluster_legalizer.get_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(helper_ctx.cluster_type[legalization_cluster_id]->name);
+            int high_fanout_threshold = helper_ctx.high_fanout_thresholds.get_threshold(helper_ctx.cluster_legalizer.get_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)
@@ -281,9 +278,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[helper_ctx.cluster_type[legalization_cluster_id]->index]);
+            cur_cluster_placement_stats_ptr = &(helper_ctx.cluster_legalizer.cluster_placement_stats[helper_ctx.cluster_legalizer.get_cluster_type(legalization_cluster_id)->index]);
             cluster_stats.num_unrelated_clustering_attempts = 0;
-            next_molecule = get_molecule_for_cluster(helper_ctx.cluster_pb[legalization_cluster_id],
+            next_molecule = get_molecule_for_cluster(helper_ctx.cluster_legalizer.get_cluster_pb(legalization_cluster_id),
                                                      attraction_groups,
                                                      allow_unrelated_clustering,
                                                      packer_opts.prioritize_transitive_connectivity,

vpr/src/pack/cluster_legalizer.h

@@ -202,6 +202,12 @@ class ClusterLegalizer {
     // FIXME: If we had a get_atom_primitive_pb that could remove a lot of
     //        leaked state!
 
+    inline t_logical_block_type_ptr get_cluster_type(LegalizationClusterId cluster_id) const {
+        VTR_ASSERT_SAFE(cluster_id.is_valid() && (size_t)cluster_id < legalization_clusters.size());
+        const LegalizationCluster& cluster = legalization_clusters[cluster_id];
+        return cluster.type;
+    }
+
     inline const PartitionRegion& get_cluster_pr(LegalizationClusterId cluster_id) const {
         VTR_ASSERT_SAFE(cluster_id.is_valid() && (size_t)cluster_id < legalization_clusters.size());
         const LegalizationCluster& cluster = legalization_clusters[cluster_id];

vpr/src/pack/cluster_util.cpp

@@ -87,7 +87,7 @@ static void echo_clusters(char* filename) {
     }
 
     for (auto& cluster_atom : cluster_atoms) {
-        const std::string& cluster_name = helper_ctx.cluster_pb[cluster_atom.first]->name;
+        const std::string& cluster_name = helper_ctx.cluster_legalizer.get_cluster_pb(cluster_atom.first)->name;
         fprintf(fp, "Cluster %s Id: %zu \n", cluster_name.c_str(), size_t(cluster_atom.first));
         fprintf(fp, "\tAtoms in cluster: \n");
 
@@ -160,7 +160,7 @@ void check_clustering() {
                             atom_ctx.nlist.block_name(blk_id).c_str());
         }
 
-        if (cur_pb != helper_ctx.cluster_pb[cluster_id]) {
+        if (cur_pb != helper_ctx.cluster_legalizer.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);
@@ -169,7 +169,8 @@ void check_clustering() {
 
     /* Check that I do not have spurious links in children pbs */
     for (LegalizationClusterId cluster_id : helper_ctx.cluster_legalizer.clusters()) {
-        check_cluster_atom_blocks(helper_ctx.cluster_pb[cluster_id], atoms_checked);
+        check_cluster_atom_blocks(helper_ctx.cluster_legalizer.get_cluster_pb(cluster_id),
+                                  atoms_checked);
     }
 
     for (auto blk_id : atom_ctx.nlist.blocks()) {
@@ -804,7 +805,7 @@ void try_fill_cluster(ClusterLegalizer& cluster_legalizer,
             }
         }
 
-        next_molecule = get_molecule_for_cluster(helper_ctx.cluster_pb[legalization_cluster_id],
+        next_molecule = get_molecule_for_cluster(helper_ctx.cluster_legalizer.get_cluster_pb(legalization_cluster_id),
                                                  attraction_groups,
                                                  allow_unrelated_clustering,
                                                  packer_opts.prioritize_transitive_connectivity,
@@ -858,7 +859,7 @@ void try_fill_cluster(ClusterLegalizer& cluster_legalizer,
     if (packer_opts.timing_driven) {
         cluster_stats.blocks_since_last_analysis++; /* historically, timing slacks were recomputed after X number of blocks were packed, but this doesn't significantly alter results so I (jluu) did not port the code */
     }
-    next_molecule = get_molecule_for_cluster(helper_ctx.cluster_pb[legalization_cluster_id],
+    next_molecule = get_molecule_for_cluster(helper_ctx.cluster_legalizer.get_cluster_pb(legalization_cluster_id),
                                              attraction_groups,
                                              allow_unrelated_clustering,
                                              packer_opts.prioritize_transitive_connectivity,
@@ -905,7 +906,7 @@ void store_cluster_info_and_free(const t_packer_opts& packer_opts,
     auto& atom_ctx = g_vpr_ctx.atom();
 
     /* store info that will be used later in packing from pb_stats and free the rest */
-    t_pb* cur_pb = helper_ctx.cluster_pb[legalization_cluster_id];
+    t_pb* cur_pb = helper_ctx.cluster_legalizer.get_cluster_pb(legalization_cluster_id);
     t_pb_stats* pb_stats = cur_pb->pb_stats;
     for (const AtomNetId mnet_id : pb_stats->marked_nets) {
         int external_terminals = atom_ctx.nlist.net_pins(mnet_id).size() - pb_stats->num_pins_of_net_in_pb[mnet_id];
@@ -932,7 +933,7 @@ void free_data_and_requeue_used_mols_if_illegal(const LegalizationClusterId lega
     const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
 
     // FIXME: This function is so simple it should be inlined.
-    num_used_type_instances[helper_ctx.cluster_type[legalization_cluster_id]]--;
+    num_used_type_instances[helper_ctx.cluster_legalizer.get_cluster_type(legalization_cluster_id)]--;
     num_clb--;
     seedindex = savedseedindex;
 
@@ -1358,8 +1359,6 @@ void start_new_cluster(ClusterLegalizer& cluster_legalizer,
             }
             cluster_pb->name = vtr::strdup(root_atom_name.c_str());
             // FIXME: Clean this up.
-            g_vpr_ctx.mutable_cl_helper().cluster_pb.insert(new_cluster_id, cluster_pb);
-            g_vpr_ctx.mutable_cl_helper().cluster_type.insert(new_cluster_id, type);
             legalization_cluster_id = new_cluster_id;
             block_type = type;
             break;
@@ -1558,7 +1557,7 @@ void add_cluster_molecule_candidates_by_attraction_group(t_pb* cur_pb,
     auto& atom_ctx = g_vpr_ctx.atom();
     const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
 
-    auto cluster_type = helper_ctx.cluster_type[legalization_cluster_id];
+    auto cluster_type = helper_ctx.cluster_legalizer.get_cluster_type(legalization_cluster_id);
 
     /*
      * For each cluster, we want to explore the attraction group molecules as potential

vpr/src/pack/output_clustering.cpp

@@ -64,13 +64,13 @@ static void count_stats_from_legalizer(std::unordered_map<AtomNetId, bool>& nets
                                        int num_clb_outputs_used[]) {
     const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
     for (LegalizationClusterId cluster_id : helper_ctx.cluster_legalizer.clusters()) {
-        auto logical_block = helper_ctx.cluster_type[cluster_id];
+        auto logical_block = helper_ctx.cluster_legalizer.get_cluster_type(cluster_id);
         auto physical_tile = pick_physical_type(logical_block);
         for (int ipin = 0; ipin < logical_block->pb_type->num_pins; ipin++) {
             int physical_pin = get_physical_pin(physical_tile, logical_block, ipin);
             auto pin_type = get_pin_type_from_pin_physical_num(physical_tile, physical_pin);
 
-            const t_pb* pb = helper_ctx.cluster_pb[cluster_id];
+            const t_pb* pb = helper_ctx.cluster_legalizer.get_cluster_pb(cluster_id);
             // FIXME: Verify this special case. It seems like it is possible
             //        for the legalizer to return an empty pb_route. In that
             //        case just return nothing.
@@ -622,11 +622,11 @@ static void clustering_xml_blocks_from_legalizer(pugi::xml_node& block_node,
     size_t pb_index = 0;
     for (LegalizationClusterId cluster_id : mutabled_helper_ctx.cluster_legalizer.clusters()) {
         clustering_xml_block(block_node,
-                             mutabled_helper_ctx.cluster_type[cluster_id],
+                             mutabled_helper_ctx.cluster_legalizer.get_cluster_type(cluster_id),
                              pb_graph_pin_lookup_from_index_by_type,
-                             mutabled_helper_ctx.cluster_pb[cluster_id],
+                             mutabled_helper_ctx.cluster_legalizer.get_cluster_pb(cluster_id),
                              pb_index,
-                             mutabled_helper_ctx.cluster_pb[cluster_id]->pb_route);
+                             mutabled_helper_ctx.cluster_legalizer.get_cluster_pb(cluster_id)->pb_route);
         pb_index++;
     }
 }

vpr/src/pack/pack.cpp

@@ -108,6 +108,7 @@ bool try_pack(t_packer_opts* packer_opts,
     bool floorplan_regions_overfull = false;
 
     // find all NoC router atoms
+    // FIXME: This belongs in the legalizer.
     auto noc_atoms = find_noc_router_atoms();
     update_noc_reachability_partitions(noc_atoms);