Changed vpr command line options used for generating test constraints files. Cleaned up attraction groups class

Author: sfkhalid

vpr/src/base/SetupVPR.cpp

@@ -612,7 +612,8 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
     PlacerOpts->place_agent_algorithm = Options.place_agent_algorithm;
     PlacerOpts->place_constraint_expand = Options.place_constraint_expand;
     PlacerOpts->place_constraint_subtile = Options.place_constraint_subtile;
-    PlacerOpts->floorplan_split = Options.floorplan_split;
+    PlacerOpts->floorplan_num_horizontal_partitions = Options.floorplan_num_horizontal_partitions;
+    PlacerOpts->floorplan_num_vertical_partitions = Options.floorplan_num_vertical_partitions;
 }
 
 static void SetupAnalysisOpts(const t_options& Options, t_analysis_opts& analysis_opts) {

vpr/src/base/read_options.cpp

@@ -491,45 +491,6 @@ struct ParseFixPins {
     }
 };
 
-struct ParseFloorplanSplit {
-    ConvertedValue<constraints_split_factor> from_str(std::string str) {
-        ConvertedValue<constraints_split_factor> conv_value;
-        if (str == "halves")
-            conv_value.set_value(HALVES);
-        else if (str == "quadrants")
-            conv_value.set_value(QUADRANTS);
-        else if (str == "sixteenths")
-            conv_value.set_value(SIXTEENTHS);
-        else if (str == "one_spot")
-            conv_value.set_value(ONE_SPOT);
-        else {
-            std::stringstream msg;
-            msg << "Invalid conversion from '" << str << "' to constraints_split_factor (expected one of: " << argparse::join(default_choices(), ", ") << ")";
-            conv_value.set_error(msg.str());
-        }
-        return conv_value;
-    }
-
-    ConvertedValue<std::string> to_str(constraints_split_factor val) {
-        ConvertedValue<std::string> conv_value;
-        if (val == HALVES)
-            conv_value.set_value("halves");
-        else if (val == QUADRANTS)
-            conv_value.set_value("quadrants");
-        else if (val == SIXTEENTHS)
-            conv_value.set_value("sixteenths");
-        else {
-            VTR_ASSERT(val == ONE_SPOT);
-            conv_value.set_value("one_spot");
-        }
-        return conv_value;
-    }
-
-    std::vector<std::string> default_choices() {
-        return {"halves", "quadrants", "sixteenths", "one_spot"};
-    }
-};
-
 struct ParseClusterSeed {
     ConvertedValue<e_cluster_seed> from_str(std::string str) {
         ConvertedValue<e_cluster_seed> conv_value;
@@ -2059,13 +2020,20 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("off")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
-    place_grp.add_argument<constraints_split_factor, ParseFloorplanSplit>(args.floorplan_split, "--floorplan_split")
-        .help(
-            "Specifies how many partitions are created from a placement when a floorplan constraint file is generated "
-            "via the --write_vpr_constraints option.")
-        .default_value("halves")
-        .choices({"halves", "quadrants", "sixteenths", "one_spot"})
+    place_grp.add_argument(args.floorplan_num_horizontal_partitions, "--floorplan_num_horizontal_partitions")
+        .help("An argument used for generating test constraints files. Specifies how many partitions to "
+        		"make in the horizontal dimension. Must be used in conjunction with "
+        		"--floorplan_num_vertical_partitions")
+        .default_value("0")
         .show_in(argparse::ShowIn::HELP_ONLY);
+
+    place_grp.add_argument(args.floorplan_num_vertical_partitions, "--floorplan_num_vertical_partitions")
+        .help("An argument used for generating test constraints files. Specifies how many partitions to "
+        		"make in the vertical dimension. Must be used in conjunction with "
+        		"--floorplan_num_horizontal_partitions")
+        .default_value("0")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     /*
      * place_grp.add_argument(args.place_timing_cost_func, "--place_timing_cost_func")
      * .help(

vpr/src/base/read_options.h

@@ -133,7 +133,8 @@ struct t_options {
     argparse::ArgValue<float> place_crit_limit;
     argparse::ArgValue<int> place_constraint_expand;
     argparse::ArgValue<bool> place_constraint_subtile;
-    argparse::ArgValue<constraints_split_factor> floorplan_split;
+    argparse::ArgValue<int> floorplan_num_horizontal_partitions;
+    argparse::ArgValue<int> floorplan_num_vertical_partitions;
 
     /* Timing-driven placement options only */
     argparse::ArgValue<float> PlaceTimingTradeoff;

vpr/src/base/vpr_api.cpp

@@ -632,7 +632,8 @@ bool vpr_place_flow(t_vpr_setup& vpr_setup, const t_arch& arch) {
 
     //Write out a vpr floorplanning constraints file if the option is specified
     if (!filename_opts.write_vpr_constraints_file.empty()) {
-        write_vpr_floorplan_constraints(filename_opts.write_vpr_constraints_file.c_str(), placer_opts.place_constraint_expand, placer_opts.place_constraint_subtile, placer_opts.floorplan_split);
+        write_vpr_floorplan_constraints(filename_opts.write_vpr_constraints_file.c_str(), placer_opts.place_constraint_expand, placer_opts.place_constraint_subtile,
+        		                        placer_opts.floorplan_num_horizontal_partitions, placer_opts.floorplan_num_vertical_partitions);
     }
 
     return true;

vpr/src/base/vpr_constraints_writer.cpp

@@ -19,17 +19,13 @@
 #include "vpr_constraints_writer.h"
 #include "region.h"
 
-void write_vpr_floorplan_constraints(const char* file_name, int expand, bool subtile, enum constraints_split_factor floorplan_split) {
+void write_vpr_floorplan_constraints(const char* file_name, int expand, bool subtile, int horizontal_partitions, int vertical_partitions) {
     VprConstraints constraints;
 
-    if (floorplan_split == HALVES) {
-        setup_vpr_floorplan_constraints_cutpoints(constraints, 2, 1);
-    } else if (floorplan_split == QUADRANTS) {
-        setup_vpr_floorplan_constraints_cutpoints(constraints, 2, 2);
-    } else if (floorplan_split == SIXTEENTHS) {
-        setup_vpr_floorplan_constraints_cutpoints(constraints, 4, 4);
-    } else { //one_spot
-        setup_vpr_floorplan_constraints(constraints, expand, subtile);
+    if (horizontal_partitions != 0 && vertical_partitions != 0) {
+    	setup_vpr_floorplan_constraints_cutpoints(constraints, horizontal_partitions, vertical_partitions);
+    } else {
+    	setup_vpr_floorplan_constraints_one_loc(constraints, expand, subtile);
     }
 
     VprConstraintsSerializer writer(constraints);
@@ -47,71 +43,18 @@ void write_vpr_floorplan_constraints(const char* file_name, int expand, bool sub
     }
 }
 
-void setup_vpr_floorplan_constraints(VprConstraints& constraints, int expand, bool subtile) {
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& place_ctx = g_vpr_ctx.placement();
-    ClusterAtomsLookup atoms_lookup;
-
-    int part_id = 0;
-    /*
-     * For each cluster block, create a partition filled with the atoms that are currently in the cluster.
-     * The PartitionRegion will be the location of the block in current placement, modified by the expansion factor.
-     * The subtile can also optionally be set in the PartitionRegion, based on the value passed in by the user.
-     */
-    for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
-        std::string part_name;
-        part_name = cluster_ctx.clb_nlist.block_name(blk_id);
-        PartitionId partid(part_id);
-
-        Partition part;
-        part.set_name(part_name);
-
-        PartitionRegion pr;
-        Region reg;
-
-        auto loc = place_ctx.block_locs[blk_id].loc;
-
-        reg.set_region_rect(loc.x - expand, loc.y - expand, loc.x + expand, loc.y + expand);
-        if (subtile) {
-            int st = loc.sub_tile;
-            reg.set_sub_tile(st);
-        }
-
-        pr.add_to_part_region(reg);
-        part.set_part_region(pr);
-        constraints.add_partition(part);
-
-        std::vector<AtomBlockId> atoms = atoms_lookup.atoms_in_cluster(blk_id);
-        int num_atoms = atoms.size();
-
-        for (auto atm = 0; atm < num_atoms; atm++) {
-            AtomBlockId atom_id = atoms[atm];
-            constraints.add_constrained_atom(atom_id, partid);
-        }
-        part_id++;
-    }
-}
-
-void setup_vpr_floorplan_constraints_half(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& place_ctx = g_vpr_ctx.placement();
     ClusterAtomsLookup atoms_lookup;
 
     int part_id = 0;
-    int block_count = 0;
-
     /*
      * For each cluster block, create a partition filled with the atoms that are currently in the cluster.
      * The PartitionRegion will be the location of the block in current placement, modified by the expansion factor.
      * The subtile can also optionally be set in the PartitionRegion, based on the value passed in by the user.
      */
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
-        if (block_count % 2 == 0) {
-            block_count++;
-            continue;
-        }
-        block_count++;
-
         std::string part_name;
         part_name = cluster_ctx.clb_nlist.block_name(blk_id);
         PartitionId partid(part_id);

vpr/src/base/vpr_constraints_writer.h

@@ -12,18 +12,14 @@
  *
  * The option --write_vpr_constraints can be used to generate the constraints files.
  *
- * Users can also use the VPR option --floorplan_split to specify which constraints files they would like to generate.
- * The options for floorplan_split include halves, quadrants, sixteenths and one_spot. One constraints file will be generated
- * in each case. The default setting for floorplan_split is halves.
+ * The routines in this file are currently used to generate floorplan constraints for testing purposes.
+ * The constraints files they generate are used to determine whether VPR is correctly adhering to
+ * floorplan constraints during its packing and placement stages.
  *
- * If the user specified halves, two floorplanning partitions would be created which each take up one half of the grid.
- * The generated constraints file would assign all primitives to one of the two partitions that were created.
- * The same idea applies for the quadrants and sixteenths options, except that the floorplan partitions would split the
- * grid into quadrants and sixteenths respectively, as the names imply.
- *
- * If the one_spot option is specified, all blocks will be locked to their original placement spot.The vpr options
- * --place_constraint_subtile and --place_constraint_expand can be used in this case to specify whether
- * the blocks should also be locked down to a particular subtile, or whether the constraint region should expand beyond one spot.
+ * The placer options --floorplan_num_horizontal_partitions (int) and --floorplan_num_vertical_partitions (int) can be used
+ * to specify how many partitions should be created in the test constraints file.
+ * For example, if both options are 2, the constraints file will split the grid into quadrants, dividing the blocks between
+ * four partitions - two partitions in the horizontal dimension, and two partitions in the vertical dimension.
  */
 
 #ifndef VPR_SRC_BASE_VPR_CONSTRAINTS_WRITER_H_
@@ -39,14 +35,16 @@
  *   @param subtile     Specifies whether to write out the constraint regions with or without
  *                      subtile values.
  */
-void write_vpr_floorplan_constraints(const char* file_name, int expand, bool subtile, enum constraints_split_factor floorplan_split);
+void write_vpr_floorplan_constraints(const char* file_name, int expand, bool subtile, int horizontal_partitions, int vertical_partitions);
 
-void setup_vpr_floorplan_constraints(VprConstraints& constraints, int expand, bool subtile);
+//Generate constraints which lock all blocks to one location.
+void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints, int expand, bool subtile);
 
+/* Generate constraints which divide the grid into partition according to the horizontal and vertical partition values passed in
+ * and lock down blocks to their appropriate partition.
+ */
 void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints, int horizontal_cutpoints, int vertical_cutpoints);
 
-void setup_vpr_floorplan_constraints_half(VprConstraints& constraints, int expand, bool subtile);
-
 void create_partition(Partition& part, std::string part_name, int xmin, int ymin, int xmax, int ymax);
 
 #endif /* VPR_SRC_BASE_VPR_CONSTRAINTS_WRITER_H_ */

vpr/src/base/vpr_types.h

@@ -928,13 +928,6 @@ enum e_pad_loc_type {
     RANDOM
 };
 
-enum constraints_split_factor {
-    HALVES,
-    QUADRANTS,
-    SIXTEENTHS,
-    ONE_SPOT
-};
-
 /**
  * @brief Used to determine the RL agent's algorithm
  *
@@ -1029,9 +1022,6 @@ enum class e_place_delta_delay_algorithm {
  *   @param place_constraint_subtile
  *              True if subtiles should be specified when printing floorplan
  *              constraints. False if not.
- *   @param floorplan split
- *              Option specifying whether to split floorplan constraint regions into
- *              halves, quadrants, sixteenths, or one_spot.
  */
 struct t_placer_opts {
     t_place_algorithm place_algorithm;
@@ -1085,7 +1075,8 @@ struct t_placer_opts {
     float place_crit_limit;
     int place_constraint_expand;
     bool place_constraint_subtile;
-    enum constraints_split_factor floorplan_split;
+    int floorplan_num_horizontal_partitions;
+    int floorplan_num_vertical_partitions;
 
     /**
      * @brief Tile types that should be used during delay sampling.

vpr/src/pack/attraction_groups.cpp

@@ -42,45 +42,6 @@ AttractionInfo::AttractionInfo(bool attraction_groups_on) {
     }
 }
 
-void AttractionInfo::reset_attraction_groups() {
-    auto& floorplanning_ctx = g_vpr_ctx.mutable_floorplanning();
-    auto& atom_ctx = g_vpr_ctx.atom();
-    int num_parts = floorplanning_ctx.constraints.get_num_partitions();
-
-    //clear the data structures before continuing
-    atom_attraction_group.clear();
-    attraction_groups.clear();
-    //Initialize every atom to have no attraction group id
-    int num_atoms = atom_ctx.nlist.blocks().size();
-
-    atom_attraction_group.resize(num_atoms);
-    fill(atom_attraction_group.begin(), atom_attraction_group.end(), AttractGroupId::INVALID());
-
-    for (int ipart = 0; ipart < num_parts; ipart++) {
-        PartitionId partid(ipart);
-
-        AttractionGroup group_info;
-        group_info.group_atoms = floorplanning_ctx.constraints.get_part_atoms(partid);
-
-        attraction_groups.push_back(group_info);
-    }
-
-    //Then, fill in the group id for the atoms that do have an attraction group
-    int num_att_grps = attraction_groups.size();
-
-    for (int igroup = 0; igroup < num_att_grps; igroup++) {
-        AttractGroupId group_id(igroup);
-
-        AttractionGroup att_group = attraction_groups[group_id];
-
-        for (unsigned int iatom = 0; iatom < att_group.group_atoms.size(); iatom++) {
-            atom_attraction_group[att_group.group_atoms[iatom]] = group_id;
-        }
-    }
-
-    VTR_LOG("%d attraction groups were created \n", num_att_grps);
-}
-
 void AttractionInfo::create_att_groups_for_overfull_regions() {
     auto& floorplanning_ctx = g_vpr_ctx.mutable_floorplanning();
     auto& atom_ctx = g_vpr_ctx.atom();
@@ -143,11 +104,7 @@ void AttractionInfo::create_att_groups_for_overfull_regions() {
 
     att_group_pulls = 1;
 
-    VTR_LOG("Number of attraction groups created is %d \n", num_att_grps);
-}
-
-AttractionGroup& AttractionInfo::get_attraction_group_info(const AttractGroupId group_id) {
-    return attraction_groups[group_id];
+    VTR_LOG("%d clustering attraction groups created. \n", num_att_grps);
 }
 
 void AttractionInfo::set_attraction_group_info(AttractGroupId group_id, const AttractionGroup& group_info) {

vpr/src/pack/attraction_groups.h

@@ -50,8 +50,6 @@ class AttractionInfo {
     //If no constraints were specified, then no attraction groups will be created.
     AttractionInfo(bool attraction_groups_on);
 
-    void reset_attraction_groups();
-
     void create_att_groups_for_overfull_regions();
 
     //Setters and getters for the class
@@ -83,7 +81,12 @@ class AttractionInfo {
     //Store atoms and gain value that belong to each attraction group
     vtr::vector<AttractGroupId, AttractionGroup> attraction_groups;
 
-    //The number of times we explore a cluster's attraction group molecules when packing a cluster
+    /* When packing a cluster with molecules, we have various ways of seeking candidates molecule
+     * candidates for the cluster. The att_group_pulls value is a way of keeping count of how many
+     * times a cluster has searched for candidate molecules from its attraction group. We can increase
+     * this value if we want to pack the cluster more densely (i.e. fill it with more molecules from
+     * its attraction group).
+     */
     int att_group_pulls = 1;
 };
 
@@ -116,4 +119,8 @@ inline void AttractionInfo::set_attraction_group_gain(const AttractGroupId group
     attraction_groups[group_id].gain = new_gain;
 }
 
+inline AttractionGroup& AttractionInfo::get_attraction_group_info(const AttractGroupId group_id) {
+    return attraction_groups[group_id];
+}
+
 #endif /* VPR_SRC_PACK_ATTRACTION_GROUPS_H_ */