vpr: Add command-line option to control routing of constant nets

kmurray · kmurray · commit 29c66b19ff90 · 2018-02-14T14:54:37.000-05:00
The new option '--constant_net_method' controls how nets driven by a constant value are treated by VPR: * global: The nets are treated as global and not routed * route : The nets are treated as regular nets and routed The default is 'global' to match previous behaviour. Warnings are produced if a global net connects to a non-global pin. In the longer term VPR should be taught to understand which pins in an architecture are tie-able to vcc/gnd (Issue #163). The 'global' method above is effectively an approximation of this where it is assumed all pins in the architecture are tie-able.
diff --git a/vpr/src/base/check_netlist.cpp b/vpr/src/base/check_netlist.cpp
@@ -21,7 +21,7 @@ using namespace std;
 
 /**************** Subroutines local to this module **************************/
 
-static int check_connections_to_global_clb_pins(ClusterNetId net_id);
+static void check_connections_to_global_clb_pins(ClusterNetId net_id);
 
 static int check_for_duplicated_names(void);
 
@@ -49,7 +49,7 @@ void check_netlist() {
 					"Net %s has multiple drivers.\n", cluster_ctx.clb_nlist.net_name(net_id).c_str());
 			error++;
 		}
-		error += check_connections_to_global_clb_pins(net_id);
+		check_connections_to_global_clb_pins(net_id);
 		if (error >= ERROR_THRESHOLD) {
 			vtr::printf_error(__FILE__, __LINE__, 
 					"Too many errors in netlist, exiting.\n");
@@ -74,39 +74,14 @@ void check_netlist() {
 		vpr_throw(VPR_ERROR_OTHER, __FILE__, __LINE__, 
 				"Found %d fatal Errors in the input netlist.\n", error);
 	}
-
-	/* 
-     * Enhanced HACK: July 2017 
-     *     Do not route constant nets (e.g. gnd/vcc). Identifying these nets as constants 
-     *     is more robust than the previous approach (exact name match to gnd/vcc).
-     *     Note that by not routing constant nets we are implicitly assuming that all pins 
-     *     in the FPGA can be tied to gnd/vcc, and hence we do not need to route them.
-	 * 
-     * TODO: We should ultimately make this architecture driven (e.g. specify which
-     *       pins which can be tied to gnd/vcc), and then route from those pins to
-     *       deliver any constants to those primitive input pins which can not be directly 
-     *       tied directly to gnd/vcc.
-	 */
-    auto& atom_ctx = g_vpr_ctx.atom();
-	for (auto net_id : cluster_ctx.clb_nlist.nets()) {
-        AtomNetId atom_net = atom_ctx.lookup.atom_net(net_id);
-        VTR_ASSERT(atom_net);
-
-        if (atom_ctx.nlist.net_is_constant(atom_net)) {
-            //Mark net as global, so that it is not routed
-            vtr::printf_warning(__FILE__, __LINE__, "Treating constant net '%s' as global, so it will not be routed\n", atom_ctx.nlist.net_name(atom_net).c_str());
-            cluster_ctx.clb_nlist.set_net_is_global(net_id, true);
-        }
-	}
 }
 
 /* Checks that a global net (net_id) connects only to global CLB input pins  *
 * and that non-global nets never connects to a global CLB pin.  Either       *
 * global or non-global nets are allowed to connect to pads.                  */
-static int check_connections_to_global_clb_pins(ClusterNetId net_id) {
+static void check_connections_to_global_clb_pins(ClusterNetId net_id) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
 	
-	unsigned int error = 0;
 	bool is_global_net = cluster_ctx.clb_nlist.net_is_global(net_id);
 
 	/* For now global signals can be driven by an I/O pad or any CLB output       *
@@ -120,32 +95,13 @@ static int check_connections_to_global_clb_pins(ClusterNetId net_id) {
 		if (cluster_ctx.clb_nlist.block_type(blk_id)->is_global_pin[pin_index] != is_global_net
 			&& !is_io_type(cluster_ctx.clb_nlist.block_type(blk_id))) {
 
-			//Allow a CLB output pin to drive a global net (warning only).
-			if (pin_id == cluster_ctx.clb_nlist.net_driver(net_id) && is_global_net) {
-				vtr::printf_warning(__FILE__, __LINE__,
-					"in check_connections_to_global_clb_pins:\n");
-				vtr::printf_warning(__FILE__, __LINE__,
-					"\tnet #%d (%s) is driven by CLB output pin (#%d) on block #%d (%s).\n",
-					net_id, cluster_ctx.clb_nlist.net_name(net_id).c_str(), pin_index, blk_id, cluster_ctx.clb_nlist.block_name(blk_id).c_str());
-			}
-			else { //Otherwise -> Error
-				vtr::printf_error(__FILE__, __LINE__,
-					"in check_connections_to_global_clb_pins:\n");
-				vtr::printf_error(__FILE__, __LINE__,
-					"\tpin %d on net #%d (%s) connects to CLB input pin (#%d) on block #%d (%s).\n",
-					pin_id, net_id, cluster_ctx.clb_nlist.net_name(net_id).c_str(), pin_index, blk_id, cluster_ctx.clb_nlist.block_name(blk_id).c_str());
-				error++;
-			}
-
-			if (is_global_net)
-				vtr::printf_info("Net is global, but CLB pin is not.\n");
-			else
-				vtr::printf_info("CLB pin is global, but net is not.\n");
-			vtr::printf_info("\n");
+            vtr::printf_warning(__FILE__, __LINE__,
+                    "Global net '%s' connects to non-global architecture pin '%s' (netlist pin '%s')\n",
+                    cluster_ctx.clb_nlist.net_name(net_id).c_str(),
+                    block_type_pin_index_to_name(cluster_ctx.clb_nlist.block_type(blk_id), pin_index).c_str(),
+                    cluster_ctx.clb_nlist.pin_name(pin_id).c_str());
 		}
 	}
-
-	return error;
 }
 
 /* Checks that the connections into and out of the clb make sense.  */
diff --git a/vpr/src/base/constant_nets.cpp b/vpr/src/base/constant_nets.cpp
@@ -0,0 +1,40 @@
+#include "constant_nets.h"
+
+#include "clustered_netlist.h"
+
+#include "vtr_assert.h"
+
+
+
+void process_constant_nets(ClusteredNetlist& nlist, e_constant_net_method method) {
+
+    if (method == CONSTANT_NET_GLOBAL) {
+        /* 
+         * Treat constant nets (e.g. gnd/vcc) as globals so they are not routed.
+         * Identifying these nets as constants is more robust than the previous 
+         * approach (exact name match to gnd/vcc).
+         *
+         * Note that by not routing constant nets we are implicitly assuming that all pins 
+         * in the FPGA can be tied to gnd/vcc, and hence we do not need to route them.
+         */
+        for (ClusterNetId net : nlist.nets()) {
+
+            if (nlist.net_is_constant(net)) {
+                //Mark net as global, so that it is not routed
+                vtr::printf_warning(__FILE__, __LINE__, "Treating constant net '%s' as global (will not be routed)\n",
+                        nlist.net_name(net).c_str());
+                nlist.set_net_is_global(net, true);
+            }
+        }
+    } else {
+        VTR_ASSERT(method == CONSTANT_NET_ROUTE);
+         /* Treat constants the same as any other net, so they will be routed. Note that this requires
+          * they have a valid driver (e.g. constant LUT).
+          *
+          * TODO: We should ultimately make this architecture driven (e.g. specify which
+          *       pins which can be tied to gnd/vcc), and then route from those pins to
+          *       deliver any constants to those primitive input pins which can not be directly 
+          *       tied directly to gnd/vcc.
+          */
+    }
+}
diff --git a/vpr/src/base/constant_nets.h b/vpr/src/base/constant_nets.h
@@ -0,0 +1,13 @@
+#ifndef CONSTANT_NETS_H
+#define CONSTANT_NETS_H
+
+#include "clustered_netlist_fwd.h"
+
+enum e_constant_net_method {
+    CONSTANT_NET_GLOBAL, //Treat constant nets as globals (i.e. not routed)
+    CONSTANT_NET_ROUTE   //Treat constant nets a non-globals (i.e. routed)
+};
+
+void process_constant_nets(ClusteredNetlist& nlist, e_constant_net_method method);
+
+#endif
diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp
@@ -1,4 +1,5 @@
 #include "read_options.h"
+#include "constant_nets.h"
 #include "vpr_error.h"
 
 #include "argparse.hpp"
@@ -214,6 +215,26 @@ struct ParseClusterSeed {
     }
 };
 
+struct ParseConstantNetMethod {
+    e_constant_net_method from_str(std::string str) {
+        if      (str == "global") return CONSTANT_NET_GLOBAL;
+        else if (str == "route")  return CONSTANT_NET_ROUTE;
+        std::stringstream msg;
+        msg << "Invalid conversion from '" << str << "' to e_constant_net_method (expected one of: " << argparse::join(default_choices(), ", ") << ")";
+        throw argparse::ArgParseConversionError(msg.str());
+    }
+
+    std::string to_str(e_constant_net_method val) {
+        if (val == CONSTANT_NET_GLOBAL) return "global";
+        VTR_ASSERT(val == CONSTANT_NET_ROUTE);
+        return "route";
+    }
+
+    std::vector<std::string> default_choices() {
+        return {"global", "route"};
+    }
+};
+
 static argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& args) {
     std::string description = "Implements the specified circuit onto the target FPGA architecture"
                               " by performing packing/placement/routing, and analyzes the result.\n"
@@ -357,6 +378,15 @@ static argparse::ArgumentParser create_arg_parser(std::string prog_name, t_optio
             .default_value("1.0")
             .show_in(argparse::ShowIn::HELP_ONLY);
 
+    gen_grp.add_argument<e_constant_net_method,ParseConstantNetMethod>(args.constant_net_method, "--constant_net_method")
+            .help("Specifies how constant nets (i.e. those driven to a constant\n"
+                  "value) are handled:\n"
+                  " * global: Treat constant nets as globals (not routed)\n"
+                  " * route : Treat constant nets as normal nets (routed)\n")
+            .default_value("global")
+            .show_in(argparse::ShowIn::HELP_ONLY);
+
+
     auto& file_grp = parser.add_argument_group("file options");
 
     file_grp.add_argument(args.BlifFile, "--circuit_file")
@@ -369,9 +399,9 @@ static argparse::ArgumentParser create_arg_parser(std::string prog_name, t_optio
                   " * blif: Strict structural BLIF format\n"
                   " * eblif: Structure BLIF format with the extensions:\n"
                   "           .conn  - Connection between two wires\n"
-                  "           .cname - Custom name for atom primitives\n"
-                  "           .param - Parameters on atom primitives\n"
-                  "           .attr  - Attributes on atom primitives\n")
+                  "           .cname - Custom name for atom primitive\n"
+                  "           .param - Parameter on atom primitive\n"
+                  "           .attr  - Attribute on atom primitive\n")
             .default_value("auto")
             .show_in(argparse::ShowIn::HELP_ONLY);
 
diff --git a/vpr/src/base/read_options.h b/vpr/src/base/read_options.h
@@ -3,6 +3,7 @@
 #include "read_blif.h"
 
 #include "vpr_types.h"
+#include "constant_nets.h"
 #include "argparse_value.hpp"
 
 struct t_options {
@@ -47,6 +48,7 @@ struct t_options {
     argparse::ArgValue<bool> verify_file_digests;
     argparse::ArgValue<std::string> device_layout;
     argparse::ArgValue<float> target_device_utilization;
+    argparse::ArgValue<e_constant_net_method> constant_net_method;
 
     /* Atom netlist options */
     argparse::ArgValue<bool> absorb_buffer_luts;
diff --git a/vpr/src/base/vpr_api.cpp b/vpr/src/base/vpr_api.cpp
@@ -66,6 +66,7 @@ using namespace std;
 #include "net_delay.h"
 #include "RoutingDelayCalculator.h"
 #include "check_route.h"
+#include "constant_nets.h"
 
 #include "timing_graph_builder.h"
 #include "timing_reports.h"
@@ -201,9 +202,9 @@ void vpr_init(const int argc, const char **argv,
     }
 #endif
 
-    /* Timing option priorities */
     vpr_setup->TimingEnabled = options->timing_analysis;
     vpr_setup->device_layout = options->device_layout;
+    vpr_setup->constant_net_method = options->constant_net_method;
 
     vtr::printf_info("\n");
     vtr::printf_info("Architecture file: %s\n", options->ArchFile.value().c_str());
@@ -502,8 +503,11 @@ void vpr_load_packing(t_vpr_setup& vpr_setup, const t_arch& arch) {
 
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
 
-    cluster_ctx.clb_nlist = read_netlist(vpr_setup.FileNameOpts.NetFile.c_str(), &arch, vpr_setup.FileNameOpts.verify_file_digests);
+    cluster_ctx.clb_nlist = read_netlist(vpr_setup.FileNameOpts.NetFile.c_str(), 
+                                         &arch,
+                                         vpr_setup.FileNameOpts.verify_file_digests);
 
+    process_constant_nets(cluster_ctx.clb_nlist, vpr_setup.constant_net_method);
 }
 
 bool vpr_place_flow(t_vpr_setup& vpr_setup, const t_arch& arch) {
diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h
@@ -28,6 +28,7 @@
 #include "arch_types.h"
 #include "atom_netlist_fwd.h"
 #include "clustered_netlist_fwd.h"
+#include "constant_nets.h"
 
 #include "vtr_assert.h"
 #include "vtr_ndmatrix.h"
@@ -1117,6 +1118,7 @@ struct t_vpr_setup {
 	int GraphPause; /* user interactiveness graphics option */
 	t_power_opts PowerOpts;
     std::string device_layout;
+    e_constant_net_method constant_net_method; //How constant nets should be handled
 };
 
 class RouteStatus {
