[SQUASH ME] Fixed Bug with partition region legalization

Author: AlexandreSinger

vpr/src/base/read_netlist.cpp

@@ -10,13 +10,11 @@
 #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"

vpr/src/base/vpr_api.cpp

@@ -614,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);
 

vpr/src/base/vpr_constraints_writer.cpp

@@ -29,13 +29,9 @@ 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);
@@ -53,9 +49,7 @@ 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();
 

vpr/src/base/vpr_constraints_writer.h

@@ -52,9 +52,7 @@ 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.
@@ -66,8 +64,6 @@ void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints,
  * @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/pack/cluster.cpp

@@ -367,7 +367,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     }
 
     //check_floorplan_regions(floorplan_regions_overfull);
-    floorplan_regions_overfull = floorplan_constraints_regions_overfull();
+    floorplan_regions_overfull = floorplan_constraints_regions_overfull(cluster_legalizer);
 
     // Ensure that we have kept track of the number of clusters correctly.
     // TODO: The total_clb_num variable could probably just be replaced by

vpr/src/pack/cluster_legalizer.cpp

@@ -195,7 +195,7 @@ static bool check_cluster_floorplanning(AtomBlockId atom_blk_id,
 
     // Get the Atom and Cluster Partition Regions
     const PartitionRegion& atom_pr = constraints.get_partition_pr(part_id);
-    
+
     // If the Cluster's PartitionRegion is empty, then this atom's PR becomes
     // the Cluster's new PartitionRegion.
     if (cluster_pr.empty()) {
@@ -539,7 +539,7 @@ try_place_atom_block_rec(const t_pb_graph_node* pb_graph_node,
     }
     pb_type = pb_graph_node->pb_type;
 
-    /* Any pb_type under an mode, which is disabled for packing, should not be considerd for mapping 
+    /* Any pb_type under an mode, which is disabled for packing, should not be considerd for mapping
      * Early exit to flag failure
      */
     if (true == pb_type->parent_mode->disable_packing) {
@@ -1048,7 +1048,7 @@ static void commit_lookahead_pins_used(t_pb* cur_pb) {
  *
  * The cleaning itself includes deleting all child pbs, resetting mode of the
  * pb and also freeing its name. This prepares the pb for another round of
- * molecule packing tryout. 
+ * molecule packing tryout.
  */
 static bool cleanup_pb(t_pb* pb) {
     bool can_free = true;
@@ -1201,7 +1201,7 @@ e_block_pack_status ClusterLegalizer::try_pack_molecule(t_pack_molecule* molecul
             VTR_LOGV(log_verbosity > 3, "\t\tFAILED No candidate primitives available\n");
             block_pack_status = e_block_pack_status::BLK_FAILED_FEASIBLE;
             break; /* no more candidate primitives available, this molecule will not pack, return fail */
-        } 
+        }
 
         block_pack_status = e_block_pack_status::BLK_PASSED;
         int failed_location = 0;

vpr/src/pack/cluster_util.cpp

@@ -79,7 +79,7 @@ void calc_init_packing_timing(const t_packer_opts& packer_opts,
                               std::shared_ptr<PreClusterDelayCalculator>& clustering_delay_calc,
                               std::shared_ptr<SetupTimingInfo>& timing_info,
                               vtr::vector<AtomBlockId, float>& atom_criticality) {
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     /*
      * Initialize the timing analyzer
@@ -228,7 +228,7 @@ void rebuild_attraction_groups(AttractionInfo& attraction_groups,
 
 /* Determine if atom block is in pb */
 bool is_atom_blk_in_pb(const AtomBlockId blk_id, const t_pb* pb) {
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     const t_pb* cur_pb = atom_ctx.lookup.atom_pb(blk_id);
     while (cur_pb) {
@@ -514,7 +514,7 @@ void update_connection_gain_values(const AtomNetId net_id,
                                    enum e_net_relation_to_clustered_block net_relation_to_clustered_block) {
     /*This function is called when the connectiongain values on the net net_id*
      *require updating.   */
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     int num_internal_connections, num_open_connections, num_stuck_connections;
 
@@ -597,8 +597,8 @@ void try_fill_cluster(ClusterLegalizer& cluster_legalizer,
                       const int& unclustered_list_head_size,
                       std::unordered_map<AtomNetId, int>& net_output_feeds_driving_block_input,
                       std::map<const t_model*, std::vector<t_logical_block_type_ptr>>& primitive_candidate_block_types) {
-    auto& atom_ctx = g_vpr_ctx.atom();
-    auto& device_ctx = g_vpr_ctx.mutable_device();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
 
     block_pack_status = cluster_legalizer.add_mol_to_cluster(next_molecule,
                                                              legalization_cluster_id);
@@ -714,7 +714,7 @@ void store_cluster_info_and_free(const t_packer_opts& packer_opts,
                                  std::vector<int>& le_count,
                                  const ClusterLegalizer& cluster_legalizer,
                                  vtr::vector<LegalizationClusterId, std::vector<AtomNetId>>& clb_inter_blk_nets) {
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& 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 = cluster_legalizer.get_cluster_pb(legalization_cluster_id);
@@ -746,7 +746,7 @@ void update_timing_gain_values(const AtomNetId net_id,
      *net_id requires updating.   */
     float timinggain;
 
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     /* Check if this atom net lists its driving atom block twice.  If so, avoid  *
      * double counting this atom block by skipping the first (driving) pin. */
@@ -811,7 +811,7 @@ void mark_and_update_partial_gain(const AtomNetId net_id,
      * cluster. The timinggain is the criticality of the most critical*
      * atom net between this atom block and an atom block in the cluster.             */
 
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
     t_pb* cur_pb = atom_ctx.lookup.atom_pb(clustered_blk_id)->parent_pb;
     cur_pb = get_top_level_pb(cur_pb);
 
@@ -889,7 +889,7 @@ void update_total_gain(float alpha, float beta, bool timing_driven, bool connect
     /*Updates the total  gain array to reflect the desired tradeoff between*
      *input sharing (sharinggain) and path_length minimization (timinggain)
      *input each time a new molecule is added to the cluster.*/
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
     t_pb* cur_pb = pb;
 
     cur_pb = get_top_level_pb(cur_pb);
@@ -966,7 +966,7 @@ void update_cluster_stats(const t_pack_molecule* molecule,
     int iblock;
     t_pb *cur_pb, *cb;
 
-    auto& atom_ctx = g_vpr_ctx.mutable_atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
     molecule_size = get_array_size_of_molecule(molecule);
     cb = nullptr;
 
@@ -1079,13 +1079,9 @@ void start_new_cluster(ClusterLegalizer& cluster_legalizer,
      * It expands the FPGA if it cannot find a legal cluster for the atom block
      */
 
-    auto& atom_ctx = g_vpr_ctx.atom();
-    auto& device_ctx = g_vpr_ctx.mutable_device();
-    auto& floorplanning_ctx = g_vpr_ctx.mutable_floorplanning();
-
-    /*Cluster's PartitionRegion is empty initially, meaning it has no floorplanning constraints*/
-    PartitionRegion empty_pr;
-    floorplanning_ctx.cluster_constraints.push_back(empty_pr);
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
+    DeviceContext& mutable_device_ctx = g_vpr_ctx.mutable_device();
+    const DeviceContext& device_ctx = g_vpr_ctx.mutable_device();
 
     /* Allocate a dummy initial cluster and load a atom block as a seed and check if it is legal */
     AtomBlockId root_atom = molecule->atom_block_ids[molecule->root];
@@ -1177,7 +1173,7 @@ void start_new_cluster(ClusterLegalizer& cluster_legalizer,
     }
 
     if (num_used_type_instances[block_type] > num_instances) {
-        device_ctx.grid = create_device_grid(device_layout_name, arch->grid_layouts, num_used_type_instances, target_device_utilization);
+        mutable_device_ctx.grid = create_device_grid(device_layout_name, arch->grid_layouts, num_used_type_instances, target_device_utilization);
     }
 }
 
@@ -1294,7 +1290,7 @@ void add_cluster_molecule_candidates_by_connectivity_and_timing(t_pb* cur_pb,
                                                                 AttractionInfo& attraction_groups) {
     VTR_ASSERT(cur_pb->pb_stats->num_feasible_blocks == NOT_VALID);
 
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     cur_pb->pb_stats->num_feasible_blocks = 0;
     cur_pb->pb_stats->explore_transitive_fanout = true; /* If no legal molecules found, enable exploration of molecules two hops away */
@@ -1322,12 +1318,12 @@ void add_cluster_molecule_candidates_by_highfanout_connectivity(t_pb* cur_pb,
     /* Because the packer ignores high fanout nets when marking what blocks
      * to consider, use one of the ignored high fanout net to fill up lightly
      * related blocks */
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
+
     reset_tried_but_unused_cluster_placements(cluster_placement_stats_ptr);
 
     AtomNetId net_id = cur_pb->pb_stats->tie_break_high_fanout_net;
 
-    auto& atom_ctx = g_vpr_ctx.atom();
-
     int count = 0;
     for (auto pin_id : atom_ctx.nlist.net_pins(net_id)) {
         if (count >= AAPACK_MAX_HIGH_FANOUT_EXPLORE) {
@@ -1366,7 +1362,7 @@ void add_cluster_molecule_candidates_by_attraction_group(t_pb* cur_pb,
                                                          const int feasible_block_array_size,
                                                          LegalizationClusterId legalization_cluster_id,
                                                          std::map<const t_model*, std::vector<t_logical_block_type_ptr>>& primitive_candidate_block_types) {
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     auto cluster_type = cluster_legalizer.get_cluster_type(legalization_cluster_id);
 
@@ -1774,7 +1770,7 @@ std::vector<AtomBlockId> initialize_seed_atoms(const e_cluster_seed seed_type,
 t_pack_molecule* get_highest_gain_seed_molecule(int& seed_index,
                                                 const std::vector<AtomBlockId>& seed_atoms,
                                                 const ClusterLegalizer& cluster_legalizer) {
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     while (seed_index < static_cast<int>(seed_atoms.size())) {
         AtomBlockId blk_id = seed_atoms[seed_index++];
@@ -1808,7 +1804,7 @@ float get_molecule_gain(t_pack_molecule* molecule, std::map<AtomBlockId, float>&
     float gain;
     int i;
     int num_introduced_inputs_of_indirectly_related_block;
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     gain = 0;
     float attraction_group_penalty = 0.1;
@@ -1873,7 +1869,7 @@ void load_transitive_fanout_candidates(LegalizationClusterId legalization_cluste
                                        const ClusterLegalizer& cluster_legalizer,
                                        vtr::vector<LegalizationClusterId, std::vector<AtomNetId>>& clb_inter_blk_nets,
                                        int transitive_fanout_threshold) {
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     // iterate over all the nets that have pins in this cluster
     for (const auto net_id : pb_stats->marked_nets) {
@@ -1915,9 +1911,8 @@ void load_transitive_fanout_candidates(LegalizationClusterId legalization_cluste
 
 std::map<const t_model*, std::vector<t_logical_block_type_ptr>> identify_primitive_candidate_block_types() {
     std::map<const t_model*, std::vector<t_logical_block_type_ptr>> model_candidates;
-    auto& atom_ctx = g_vpr_ctx.atom();
-    auto& atom_nlist = atom_ctx.nlist;
-    auto& device_ctx = g_vpr_ctx.device();
+    const AtomNetlist& atom_nlist = g_vpr_ctx.atom().nlist;
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
 
     std::set<const t_model*> unique_models;
     // Find all logic models used in the netlist
@@ -1945,7 +1940,7 @@ std::map<const t_model*, std::vector<t_logical_block_type_ptr>> identify_primiti
 void print_seed_gains(const char* fname, const std::vector<AtomBlockId>& seed_atoms, const vtr::vector<AtomBlockId, float>& atom_gain, const vtr::vector<AtomBlockId, float>& atom_criticality) {
     FILE* fp = vtr::fopen(fname, "w");
 
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     //For prett formatting determine the maximum name length
     int max_name_len = strlen("atom_block_name");
@@ -2170,7 +2165,7 @@ t_pb* get_top_level_pb(t_pb* pb) {
 }
 
 void init_clb_atoms_lookup(vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>>& atoms_lookup) {
-    auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     atoms_lookup.resize(cluster_ctx.clb_nlist.blocks().size());

vpr/src/pack/constraints_report.cpp

@@ -1,9 +1,11 @@
 #include "constraints_report.h"
+#include "cluster_legalizer.h"
+#include "globals.h"
+#include "grid_tile_lookup.h"
 
-bool floorplan_constraints_regions_overfull() {
+bool floorplan_constraints_regions_overfull(const ClusterLegalizer& cluster_legalizer) {
     GridTileLookup grid_tiles;
 
-    auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& floorplanning_ctx = g_vpr_ctx.mutable_floorplanning();
     auto& device_ctx = g_vpr_ctx.device();
 
@@ -12,15 +14,13 @@ bool floorplan_constraints_regions_overfull() {
     // keep record of how many blocks of each type are assigned to each PartitionRegion
     std::unordered_map<PartitionRegion, std::vector<int>> pr_count_info;
 
-    for (const ClusterBlockId blk_id : cluster_ctx.clb_nlist.blocks()) {
-        if (!is_cluster_constrained(blk_id)) {
+    for (LegalizationClusterId cluster_id : cluster_legalizer.clusters()) {
+        const PartitionRegion& pr = cluster_legalizer.get_cluster_pr(cluster_id);
+        if (pr.empty())
             continue;
-        }
-        t_logical_block_type_ptr bt = cluster_ctx.clb_nlist.block_type(blk_id);
 
-        const PartitionRegion& pr = floorplanning_ctx.cluster_constraints[blk_id];
+        t_logical_block_type_ptr bt = cluster_legalizer.get_cluster_type(cluster_id);
         auto got = pr_count_info.find(pr);
-
         if (got == pr_count_info.end()) {
             std::vector<int> block_type_counts(block_types.size(), 0);
             block_type_counts[bt->index]++;

vpr/src/pack/constraints_report.h

@@ -5,9 +5,7 @@
 #ifndef VPR_SRC_PACK_CONSTRAINTS_REPORT_H_
 #define VPR_SRC_PACK_CONSTRAINTS_REPORT_H_
 
-#include "globals.h"
-#include "grid_tile_lookup.h"
-#include "place_constraints.h"
+class ClusterLegalizer;
 
 /**
  * @brief Check if any constraint partition regions are overfull,
@@ -27,6 +25,6 @@
  *
  * @return True if there is at least one overfull partition.
  */
-bool floorplan_constraints_regions_overfull();
+bool floorplan_constraints_regions_overfull(const ClusterLegalizer& cluster_legalizer);
 
 #endif /* VPR_SRC_PACK_CONSTRAINTS_REPORT_H_ */