Floorplanning during place moves

vpr/src/base/SetupVPR.cpp

@@ -94,6 +94,7 @@ void SetupVPR(const t_options* Options,
     FileNameOpts->CmosTechFile = Options->CmosTechFile;
     FileNameOpts->out_file_prefix = Options->out_file_prefix;
     FileNameOpts->read_vpr_constraints_file = Options->read_vpr_constraints_file;
+    FileNameOpts->write_vpr_constraints_file = Options->write_vpr_constraints_file;
 
     FileNameOpts->verify_file_digests = Options->verify_file_digests;
 
@@ -585,6 +586,8 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
     PlacerOpts->place_reward_fun = Options.place_reward_fun;
     PlacerOpts->place_crit_limit = Options.place_crit_limit;
     PlacerOpts->place_agent_algorithm = Options.place_agent_algorithm;
+    PlacerOpts->place_constraint_expand = Options.place_constraint_expand;
+    PlacerOpts->place_constraint_subtile = Options.place_constraint_subtile;
 }
 
 static void SetupAnalysisOpts(const t_options& Options, t_analysis_opts& analysis_opts) {

vpr/src/base/read_options.cpp

@@ -1413,6 +1413,10 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     file_grp.add_argument(args.read_vpr_constraints_file, "--read_vpr_constraints")
+        .help("Writes the floorplanning constraints from placement to the specified XML file.")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    file_grp.add_argument(args.write_vpr_constraints_file, "--write_vpr_constraints")
         .help("Reads the floorplanning constraints from the specified XML file.")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
@@ -1873,6 +1877,21 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
             "Its range equals to [0., 1.].")
         .default_value("0.7")
         .show_in(argparse::ShowIn::HELP_ONLY);
+
+    place_grp.add_argument(args.place_constraint_expand, "--place_constraint_expand")
+        .help(
+            "The value used to decide how much to expand the floorplan constraint region when writing"
+            "a floorplan constraint XML file. If it is zero, the block stays locked in its place. If it is"
+            "greater than zero the constraint region expands by the specified value in each direction.")
+        .default_value("0")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    place_grp.add_argument(args.place_constraint_subtile, "--place_constraint_subtile")
+        .help(
+            "The value used to specify a subtile constraints when writing a floorplan constraints XML file.")
+        .default_value("-1")
+        .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

@@ -27,6 +27,7 @@ struct t_options {
     argparse::ArgValue<std::string> write_rr_graph_file;
     argparse::ArgValue<std::string> read_rr_graph_file;
     argparse::ArgValue<std::string> read_vpr_constraints_file;
+    argparse::ArgValue<std::string> write_vpr_constraints_file;
 
     argparse::ArgValue<std::string> write_placement_delay_lookup;
     argparse::ArgValue<std::string> read_placement_delay_lookup;
@@ -128,6 +129,8 @@ struct t_options {
     argparse::ArgValue<std::string> place_reward_fun;
     //argparse::ArgValue<int> place_timing_cost_func;
     argparse::ArgValue<float> place_crit_limit;
+    argparse::ArgValue<int> place_constraint_expand;
+    argparse::ArgValue<int> place_constraint_subtile;
 
     /* Timing-driven placement options only */
     argparse::ArgValue<float> PlaceTimingTradeoff;

vpr/src/base/vpr_api.cpp

@@ -69,7 +69,7 @@
 #include "cluster.h"
 #include "output_clustering.h"
 #include "vpr_constraints_reader.h"
-
+#include "vpr_constraints_writer.h"
 #include "pack_report.h"
 #include "overuse_report.h"
 
@@ -660,11 +660,17 @@ void vpr_place(t_vpr_setup& vpr_setup, const t_arch& arch) {
               arch.num_directs);
 
     auto& filename_opts = vpr_setup.FileNameOpts;
+    auto& placer_opts = vpr_setup.PlacerOpts;
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     print_place(filename_opts.NetFile.c_str(),
                 cluster_ctx.clb_nlist.netlist_id().c_str(),
                 filename_opts.PlaceFile.c_str());
+
+    //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);
+    }
 }
 
 void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {

vpr/src/base/vpr_constraints_reader.cpp

@@ -14,7 +14,8 @@
 void load_vpr_constraints_file(const char* read_vpr_constraints_name) {
     vtr::ScopedStartFinishTimer timer("Loading VPR constraints file");
 
-    VprConstraintsSerializer reader;
+    VprConstraints constraints;
+    VprConstraintsSerializer reader(constraints);
 
     if (vtr::check_file_name_extension(read_vpr_constraints_name, ".xml")) {
         try {

vpr/src/base/vpr_constraints_serializer.h

@@ -49,11 +49,16 @@
  *
  * For more detail on how the load and write interfaces work with uxsdcxx, refer to 'vpr/src/route/SCHEMA_GENERATOR.md'
  */
+struct partition_info {
+    Partition part;
+    std::vector<AtomBlockId> atoms;
+    PartitionId part_id;
+};
 
 struct VprConstraintsContextTypes : public uxsd::DefaultVprConstraintsContextTypes {
-    using AddAtomReadContext = void*;
-    using AddRegionReadContext = void*;
-    using PartitionReadContext = void*;
+    using AddAtomReadContext = AtomBlockId;
+    using AddRegionReadContext = Region;
+    using PartitionReadContext = partition_info;
     using PartitionListReadContext = void*;
     using VprConstraintsReadContext = void*;
     using AddAtomWriteContext = void*;
@@ -65,6 +70,11 @@ struct VprConstraintsContextTypes : public uxsd::DefaultVprConstraintsContextTyp
 
 class VprConstraintsSerializer final : public uxsd::VprConstraintsBase<VprConstraintsContextTypes> {
   public:
+    //VprConstraintsSerializer() : report_error_(nullptr) {}
+    VprConstraintsSerializer(VprConstraints constraints)
+        : constraints_(constraints)
+        , report_error_(nullptr) {}
+
     void start_load(const std::function<void(const char*)>* report_error_in) final {
         // report_error_in should be invoked if VprConstraintsSerializer encounters
         // an error during the read.
@@ -89,8 +99,10 @@ class VprConstraintsSerializer final : public uxsd::VprConstraintsBase<VprConstr
      *   <xs:attribute name="name_pattern" type="xs:string" use="required" />
      * </xs:complexType>
      */
-    virtual inline const char* get_add_atom_name_pattern(void*& /*ctx*/) final {
-        return temp_.c_str();
+    virtual inline const char* get_add_atom_name_pattern(AtomBlockId& blk_id) final {
+        auto& atom_ctx = g_vpr_ctx.atom();
+        auto atom_name = atom_ctx.nlist.block_name(blk_id);
+        return atom_name.c_str();
     }
 
     virtual inline void set_add_atom_name_pattern(const char* name_pattern, void*& /*ctx*/) final {
@@ -141,33 +153,32 @@ class VprConstraintsSerializer final : public uxsd::VprConstraintsBase<VprConstr
      *   <xs:attribute name="subtile" type="xs:int" />
      * </xs:complexType>
      */
-    virtual inline int get_add_region_subtile(void*& /*ctx*/) final {
-        int i = 0;
-        return i;
+    virtual inline int get_add_region_subtile(Region& r) final {
+        return r.get_sub_tile();
     }
 
     virtual inline void set_add_region_subtile(int subtile, void*& /*ctx*/) final {
         loaded_region.set_sub_tile(subtile);
     }
 
-    virtual inline int get_add_region_x_high(void*& /*ctx*/) final {
-        int i = 0;
-        return i;
+    virtual inline int get_add_region_x_high(Region& r) final {
+        vtr::Rect<int> rect = r.get_region_rect();
+        return rect.xmax();
     }
 
-    virtual inline int get_add_region_x_low(void*& /*ctx*/) final {
-        int i = 0;
-        return i;
+    virtual inline int get_add_region_x_low(Region& r) final {
+        vtr::Rect<int> rect = r.get_region_rect();
+        return rect.xmin();
     }
 
-    virtual inline int get_add_region_y_high(void*& /*ctx*/) final {
-        int i = 0;
-        return i;
+    virtual inline int get_add_region_y_high(Region& r) final {
+        vtr::Rect<int> rect = r.get_region_rect();
+        return rect.ymax();
     }
 
-    virtual inline int get_add_region_y_low(void*& /*ctx*/) final {
-        int i = 0;
-        return i;
+    virtual inline int get_add_region_y_low(Region& r) final {
+        vtr::Rect<int> rect = r.get_region_rect();
+        return rect.ymin();
     }
 
     /** Generated for complex type "partition":
@@ -179,8 +190,8 @@ class VprConstraintsSerializer final : public uxsd::VprConstraintsBase<VprConstr
      *   <xs:attribute name="name" type="xs:string" use="required" />
      * </xs:complexType>
      */
-    virtual inline const char* get_partition_name(void*& /*ctx*/) final {
-        return temp_.c_str();
+    virtual inline const char* get_partition_name(partition_info& part_info) final {
+        return part_info.part.get_name().c_str();
     }
     virtual inline void set_partition_name(const char* name, void*& /*ctx*/) final {
         loaded_partition.set_name(name);
@@ -200,12 +211,11 @@ class VprConstraintsSerializer final : public uxsd::VprConstraintsBase<VprConstr
         }
     }
 
-    virtual inline size_t num_partition_add_atom(void*& /*ctx*/) final {
-        int i = 0;
-        return i;
+    virtual inline size_t num_partition_add_atom(partition_info& part_info) final {
+        return part_info.atoms.size();
     }
-    virtual inline void* get_partition_add_atom(int /*n*/, void*& /*ctx*/) final {
-        return nullptr;
+    virtual inline AtomBlockId get_partition_add_atom(int n, partition_info& part_info) final {
+        return part_info.atoms[n];
     }
 
     virtual inline void preallocate_partition_add_region(void*& /*ctx*/, size_t /*size*/) final {}
@@ -223,12 +233,15 @@ class VprConstraintsSerializer final : public uxsd::VprConstraintsBase<VprConstr
         loaded_region = clear_region;
     }
 
-    virtual inline size_t num_partition_add_region(void*& /*ctx*/) final {
-        int i = 0;
-        return i;
+    virtual inline size_t num_partition_add_region(partition_info& part_info) final {
+        PartitionRegion pr = part_info.part.get_part_region();
+        std::vector<Region> regions = pr.get_partition_region();
+        return regions.size();
     }
-    virtual inline void* get_partition_add_region(int /*n*/, void*& /*ctx*/) final {
-        return nullptr;
+    virtual inline Region get_partition_add_region(int n, partition_info& part_info) final {
+        PartitionRegion pr = part_info.part.get_part_region();
+        std::vector<Region> regions = pr.get_partition_region();
+        return regions[n];
     }
 
     /** Generated for complex type "partition_list":
@@ -256,12 +269,20 @@ class VprConstraintsSerializer final : public uxsd::VprConstraintsBase<VprConstr
         num_partitions_++;
     }
     virtual inline size_t num_partition_list_partition(void*& /*ctx*/) final {
-        int i = 0;
-        return i;
+        return constraints_.get_num_partitions();
     }
 
-    virtual inline void* get_partition_list_partition(int /*n*/, void*& /*ctx*/) final {
-        return nullptr;
+    virtual inline partition_info get_partition_list_partition(int n, void*& /*ctx*/) final {
+        PartitionId partid(n);
+        Partition part = constraints_.get_partition(partid);
+        std::vector<AtomBlockId> atoms = constraints_.get_part_atoms(partid);
+
+        partition_info part_info;
+        part_info.part = part;
+        part_info.part_id = partid;
+        part_info.atoms = atoms;
+
+        return part_info;
     }
 
     /** Generated for complex type "vpr_constraints":
@@ -298,16 +319,16 @@ class VprConstraintsSerializer final : public uxsd::VprConstraintsBase<VprConstr
     }
 
     //temp data for loads
+    VprConstraints constraints_;
     const std::function<void(const char*)>* report_error_;
 
     //temp data structures to be loaded during file reading
     Region loaded_region;
     Partition loaded_partition;
     PartitionRegion loaded_part_region;
-    VprConstraints constraints_;
 
     //temp string used when a method must return a const char*
-    std::string temp_;
+    std::string temp_ = "test";
 
     //used to count the number of partitions read in from the file
     int num_partitions_ = 0;

vpr/src/base/vpr_constraints_writer.cpp

@@ -0,0 +1,84 @@
+/*
+ * vpr_constraints_writer.cpp
+ *
+ *      Author: khalid88
+ */
+
+#include "vpr_constraints_serializer.h"
+#include "vpr_constraints_uxsdcxx.h"
+
+#include "vtr_time.h"
+
+#include "globals.h"
+#include "pugixml.hpp"
+#include "pugixml_util.hpp"
+#include "echo_files.h"
+
+#include <fstream>
+#include "vpr_constraints_writer.h"
+
+void write_vpr_floorplan_constraints(const char* file_name, int expand, int subtile) {
+    auto& place_ctx = g_vpr_ctx.placement();
+    auto& atom_ctx = g_vpr_ctx.atom();
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+
+    //Fill in all the info needed for locking atoms to their locations
+    VprConstraints constraints;
+
+    std::map<ClusterBlockId, std::vector<AtomBlockId>> cluster_atoms;
+
+    for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
+        cluster_atoms.insert({blk_id, std::vector<AtomBlockId>()});
+    }
+
+    for (auto atom_blk_id : atom_ctx.nlist.blocks()) {
+        ClusterBlockId clb_index = atom_ctx.lookup.atom_clb(atom_blk_id);
+
+        cluster_atoms[clb_index].push_back(atom_blk_id);
+    }
+
+    int part_id = 0;
+    for (auto i = cluster_atoms.begin(); i != cluster_atoms.end(); i++) {
+        std::string part_name;
+        part_name = cluster_ctx.clb_nlist.block_name(i->first);
+
+        PartitionId partid(part_id);
+
+        Partition part;
+        part.set_name(part_name);
+
+        PartitionRegion pr;
+        Region reg;
+
+        auto loc = place_ctx.block_locs[i->first].loc;
+
+        reg.set_region_rect(loc.x - expand, loc.y - expand, loc.x + expand, loc.y + expand);
+        reg.set_sub_tile(subtile);
+
+        pr.add_to_part_region(reg);
+        part.set_part_region(pr);
+        constraints.add_partition(part);
+
+        int num_atoms = i->second.size();
+
+        for (auto j = 0; j < num_atoms; j++) {
+            AtomBlockId atom_id = i->second[j];
+            constraints.add_constrained_atom(atom_id, partid);
+        }
+        part_id++;
+    }
+
+    VprConstraintsSerializer reader(constraints);
+
+    if (vtr::check_file_name_extension(file_name, ".xml")) {
+        std::fstream fp;
+        fp.open(file_name, std::fstream::out | std::fstream::trunc);
+        fp.precision(std::numeric_limits<float>::max_digits10);
+        void* context;
+        uxsd::write_vpr_constraints_xml(reader, context, fp);
+    } else {
+        VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
+                        "Unknown extension on output %s",
+                        file_name);
+    }
+}

vpr/src/base/vpr_constraints_writer.h

@@ -0,0 +1,12 @@
+/*
+ * vpr_constraints_writer.h
+ *
+ *      Author: khalid88
+ */
+
+#ifndef VPR_SRC_BASE_VPR_CONSTRAINTS_WRITER_H_
+#define VPR_SRC_BASE_VPR_CONSTRAINTS_WRITER_H_
+
+void write_vpr_floorplan_constraints(const char* file_name, int expand, int subtile);
+
+#endif /* VPR_SRC_BASE_VPR_CONSTRAINTS_WRITER_H_ */