Merge branch 'master' into openfpga

Author: tangxifan

README.developers.md

@@ -1092,6 +1092,12 @@ All tests passed (1 assertion in 1 test case)
 # Debugging Aids
 VTR has support for several additional tools/features to aid debugging.
 
+## Basic
+To build vpr with make in debug mode, simply add `BUILD_TYPE=debug` at the end of your make command. 
+```shell
+$ make vpr BUILD_TYPE=debug
+```
+
 ## Sanitizers
 VTR can be compiled using *sanitizers* which will detect invalid memory accesses, memory leaks and undefined behaviour (supported by both GCC and LLVM):
 ```shell

vpr/src/base/CheckSetup.cpp

@@ -23,6 +23,18 @@ void CheckSetup(const t_packer_opts& PackerOpts,
                         "Packing cannot be timing driven without timing analysis enabled\n");
     }
 
+    if (PackerOpts.load_flat_placement) {
+        if (PackerOpts.device_layout == "auto") {
+            VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                            "Legalization requires a fixed device layout.\n");
+        }
+        if (!PlacerOpts.constraints_file.empty()) {
+            VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                            "Cannot specify a fixed clusters file when running legalization.\n");
+        }
+    }
+
+
     if ((GLOBAL == RouterOpts.route_type)
         && (PlacerOpts.place_algorithm.is_timing_driven())) {
         /* Works, but very weird.  Can't optimize timing well, since you're

vpr/src/base/SetupGrid.h

@@ -13,10 +13,11 @@
 #include "physical_types.h"
 
 ///@brief Find the device satisfying the specified minimum resources
+/// minimum_instance_counts and target_device_utilization are not required when specifying a fixed layout
 DeviceGrid create_device_grid(const std::string& layout_name,
                               const std::vector<t_grid_def>& grid_layouts,
-                              const std::map<t_logical_block_type_ptr, size_t>& minimum_instance_counts,
-                              float target_device_utilization);
+                              const std::map<t_logical_block_type_ptr, size_t>& minimum_instance_counts = {},
+                              float target_device_utilization = 0.0);
 
 ///@brief Find the device close in size to the specified dimensions
 DeviceGrid create_device_grid(const std::string& layout_name,

vpr/src/base/SetupVPR.cpp

@@ -128,6 +128,7 @@ void SetupVPR(const t_options* Options,
     FileNameOpts->ArchFile = Options->ArchFile;
     FileNameOpts->CircuitFile = Options->CircuitFile;
     FileNameOpts->NetFile = Options->NetFile;
+    FileNameOpts->FlatPlaceFile = Options->FlatPlaceFile;
     FileNameOpts->PlaceFile = Options->PlaceFile;
     FileNameOpts->RouteFile = Options->RouteFile;
     FileNameOpts->ActFile = Options->ActFile;
@@ -136,6 +137,8 @@ void SetupVPR(const t_options* Options,
     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->write_constraints_file = Options->write_constraints_file;
+    FileNameOpts->write_flat_place_file = Options->write_flat_place_file;
     FileNameOpts->write_block_usage = Options->write_block_usage;
 
     FileNameOpts->verify_file_digests = Options->verify_file_digests;
@@ -239,6 +242,7 @@ void SetupVPR(const t_options* Options,
     //Setup the default flow, if no specific stages specified
     //do all
     if (!Options->do_packing
+        && !Options->do_legalize
         && !Options->do_placement
         && !Options->do_routing
         && !Options->do_analysis) {
@@ -275,6 +279,11 @@ void SetupVPR(const t_options* Options,
         if (Options->do_packing) {
             PackerOpts->doPacking = STAGE_DO;
         }
+
+        if (Options->do_legalize) {
+            PackerOpts->doPacking = STAGE_LOAD;
+            PackerOpts->load_flat_placement = true;
+        }
     }
 
     ShowSetup(*vpr_setup);

vpr/src/base/echo_files.cpp

@@ -80,6 +80,9 @@ void alloc_and_load_echo_file_info() {
     //Packing
     setEchoFileName(E_ECHO_CLUSTERS, "clusters.echo");
 
+    //Legalizer
+    setEchoFileName(E_ECHO_FLAT_PLACE, "post_legalizer_flat_placement.echo");
+
     //Intra-block routing
     setEchoFileName(E_ECHO_INTRA_LB_FAILED_ROUTE, "intra_lb_failed_route.echo");
 

vpr/src/base/echo_files.h

@@ -16,6 +16,9 @@ enum e_echo_files {
     //Packing
     E_ECHO_CLUSTERS,
 
+    //Legalizer
+    E_ECHO_FLAT_PLACE,
+
     // Intra-block routing
     E_ECHO_INTRA_LB_FAILED_ROUTE,
 

vpr/src/base/load_flat_place.cpp

@@ -0,0 +1,55 @@
+#include "globals.h"
+#include "load_flat_place.h"
+#include "clustered_netlist_utils.h"
+
+
+/* @brief Prints flat placement file entries for the atoms in one placed cluster. */
+static void print_flat_cluster(FILE* fp, ClusterBlockId iblk,
+                               std::vector<AtomBlockId>& atoms);
+
+static void print_flat_cluster(FILE* fp, ClusterBlockId iblk,
+                               std::vector<AtomBlockId>& atoms) {
+
+    auto& atom_ctx = g_vpr_ctx.atom();
+    t_pl_loc loc = g_vpr_ctx.placement().block_locs[iblk].loc;
+    size_t bnum = size_t(iblk);
+
+    for (auto atom : atoms) {
+        t_pb_graph_node* atom_pbgn = atom_ctx.lookup.atom_pb(atom)->pb_graph_node;
+        fprintf(fp, "%s  %d %d %d %d #%zu %s\n", atom_ctx.nlist.block_name(atom).c_str(),
+                                                loc.x, loc.y, loc.sub_tile,
+                                                atom_pbgn->flat_site_index,
+                                                bnum,
+                                                atom_pbgn->pb_type->name);
+    }
+}
+
+/* prints a flat placement file */
+void print_flat_placement(const char* flat_place_file) {
+
+    FILE* fp;
+
+    ClusterAtomsLookup atoms_lookup;
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+
+    if (!g_vpr_ctx.placement().block_locs.empty()) {
+        fp = fopen(flat_place_file, "w");
+        for (auto iblk : cluster_ctx.clb_nlist.blocks()) {
+            auto atoms = atoms_lookup.atoms_in_cluster(iblk);
+            print_flat_cluster(fp, iblk, atoms);
+        }
+        fclose(fp);
+    }
+
+}
+
+/* ingests and legalizes a flat placement file  */
+bool load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
+    VTR_LOG("load_flat_placement(); when implemented, this function:");
+    VTR_LOG("\n\tLoads flat placement file: %s, ", vpr_setup.FileNameOpts.FlatPlaceFile.c_str());
+    VTR_LOG("\n\tArch id: %s, ", arch.architecture_id);
+    VTR_LOG("\n\tPrints clustered netlist file: %s, ", vpr_setup.FileNameOpts.NetFile.c_str());
+    VTR_LOG("\n\tPrints fix clusters file: %s\n", vpr_setup.FileNameOpts.write_constraints_file.c_str());
+
+    return false;
+}

vpr/src/base/load_flat_place.h

@@ -0,0 +1,16 @@
+#ifndef LOAD_FLAT_PLACE_H
+#define LOAD_FLAT_PLACE_H
+
+#include "vpr_types.h"
+
+/**
+ * @brief A function that prints a flat placement file
+ */
+void print_flat_placement(const char* flat_place_file);
+
+/**
+ * @brief A function that loads and legalizes a flat placement file
+ */
+bool load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch);
+
+#endif

vpr/src/base/read_options.cpp

@@ -1310,6 +1310,11 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .action(argparse::Action::STORE_TRUE)
         .default_value("off");
 
+    stage_grp.add_argument<bool, ParseOnOff>(args.do_legalize, "--legalize")
+        .help("Legalize a flat placement, i.e. reconstruct and place clusters based on a flat placement file, which lists cluster and intra-cluster placement coordinates for each primitive.")
+        .action(argparse::Action::STORE_TRUE)
+        .default_value("off");
+
     stage_grp.add_argument<bool, ParseOnOff>(args.do_placement, "--place")
         .help("Run placement")
         .action(argparse::Action::STORE_TRUE)
@@ -1590,6 +1595,10 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .help("Path to packed netlist file")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    file_grp.add_argument(args.FlatPlaceFile, "--flat_place_file")
+        .help("Path to input flat placement file")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     file_grp.add_argument(args.PlaceFile, "--place_file")
         .help("Path to placement file")
         .show_in(argparse::ShowIn::HELP_ONLY);
@@ -1627,6 +1636,17 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .help("Writes out new floorplanning constraints based on current placement to the specified XML file.")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    file_grp.add_argument(args.write_constraints_file, "--write_fix_clusters")
+        .help(
+            "Output file containing fixed locations of legalized input clusters - does not include clusters without placement coordinates; this file is used during post-legalization placement in order to hold input placement coordinates fixed while VPR places legalizer-generated orphan clusters.")
+        .default_value("fix_clusters.out")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    file_grp.add_argument(args.write_flat_place_file, "--write_flat_place")
+        .help(
+            "VPR's (or reconstructed external) placement solution in flat placement file format; this file lists cluster and intra-cluster placement coordinates for each atom and can be used to reconstruct a clustering and placement solution.")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     file_grp.add_argument(args.read_router_lookahead, "--read_router_lookahead")
         .help(
             "Reads the lookahead data from the specified file instead of computing it.")
@@ -2997,6 +3017,12 @@ void set_conditional_defaults(t_options& args) {
         args.RouteFile.set(route_file, Provenance::INFERRED);
     }
 
+    if (args.FlatPlaceFile.provenance() != Provenance::SPECIFIED) {
+        std::string flat_place_file = args.out_file_prefix;
+        flat_place_file += default_output_name + ".flat_place";
+        args.FlatPlaceFile.set(flat_place_file, Provenance::INFERRED);
+    }
+
     if (args.ActFile.provenance() != Provenance::SPECIFIED) {
         std::string activity_file = args.out_file_prefix;
         activity_file += default_output_name + ".act";

vpr/src/base/read_options.h

@@ -12,6 +12,7 @@ struct t_options {
     argparse::ArgValue<std::string> ArchFile;
     argparse::ArgValue<std::string> CircuitName;
     argparse::ArgValue<std::string> NetFile;
+    argparse::ArgValue<std::string> FlatPlaceFile;
     argparse::ArgValue<std::string> PlaceFile;
     argparse::ArgValue<std::string> RouteFile;
     argparse::ArgValue<std::string> CircuitFile;
@@ -30,6 +31,8 @@ struct t_options {
     argparse::ArgValue<std::string> write_initial_place_file;
     argparse::ArgValue<std::string> read_vpr_constraints_file;
     argparse::ArgValue<std::string> write_vpr_constraints_file;
+    argparse::ArgValue<std::string> write_constraints_file;
+    argparse::ArgValue<std::string> write_flat_place_file;
 
     argparse::ArgValue<std::string> write_placement_delay_lookup;
     argparse::ArgValue<std::string> read_placement_delay_lookup;
@@ -44,6 +47,7 @@ struct t_options {
 
     /* Stage Options */
     argparse::ArgValue<bool> do_packing;
+    argparse::ArgValue<bool> do_legalize;
     argparse::ArgValue<bool> do_placement;
     argparse::ArgValue<bool> do_routing;
     argparse::ArgValue<bool> do_analysis;

vpr/src/base/read_place.cpp

@@ -309,7 +309,8 @@ void read_place_body(std::ifstream& placement_file,
  */
 void print_place(const char* net_file,
                  const char* net_id,
-                 const char* place_file) {
+                 const char* place_file,
+                 bool is_place_file) {
     FILE* fp;
 
     auto& device_ctx = g_vpr_ctx.device();
@@ -318,15 +319,21 @@ void print_place(const char* net_file,
 
     fp = fopen(place_file, "w");
 
-    fprintf(fp, "Netlist_File: %s Netlist_ID: %s\n",
-            net_file,
-            net_id);
-    fprintf(fp, "Array size: %zu x %zu logic blocks\n\n", device_ctx.grid.width(), device_ctx.grid.height());
-    fprintf(fp, "#block name\tx\ty\tsubblk\tlayer\tblock number\n");
-    fprintf(fp, "#----------\t--\t--\t------\t-----\t------------\n");
+    if (is_place_file) {
+        fprintf(fp, "Netlist_File: %s Netlist_ID: %s\n",
+                net_file,
+                net_id);
+        fprintf(fp, "Array size: %zu x %zu logic blocks\n\n", device_ctx.grid.width(), device_ctx.grid.height());
+        fprintf(fp, "#block name\tx\ty\tsubblk\tlayer\tblock number\n");
+        fprintf(fp, "#----------\t--\t--\t------\t-----\t------------\n");
+    }
 
     if (!place_ctx.block_locs.empty()) { //Only if placement exists
         for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
+            // if block is not placed, skip (useful for printing legalizer output)
+            if (!is_place_file && (place_ctx.block_locs[blk_id].loc.x == INVALID_X)) {
+                continue;
+            }
             fprintf(fp, "%s\t", cluster_ctx.clb_nlist.block_pb(blk_id)->name);
             if (strlen(cluster_ctx.clb_nlist.block_pb(blk_id)->name) < 8)
                 fprintf(fp, "\t");

vpr/src/base/read_place.h

@@ -17,8 +17,19 @@ void read_place(
  */
 void read_constraints(const char* constraints_file);
 
+/**
+ * This function prints out a place file.
+ * @param is_place_file: defaults to true. If false, does not print file header; this is useful if
+ *                       the output will be used as a constraints file. If is_place_file is false,
+ *                       net_file and net_id parameters are not used and can be set to nullptr.
+ *                       Note: if false, only placed clusters are printed - clusters without
+ *                       placement coordinates (e.g. orphan clusters created during legalization
+ *                       will not be included; this file is used as a placement constraints
+ *                       file when running placement in order to place orphan clusters.
+ */
 void print_place(const char* net_file,
                  const char* net_id,
-                 const char* place_file);
+                 const char* place_file,
+                 bool is_place_file = true);
 
 #endif