Support route constraint.

doc/src/vpr/command_line_usage.rst

@@ -358,13 +358,13 @@ Use the options below to override this default naming behaviour.
 
     .. seealso:: :ref:`Routing Resource XML File <vpr_route_resource_file>`.
 
-.. option:: --read_vpr_constraints <file>
+.. option:: --read_vpr_constraints <file1>:<file2>:...:<fileN>
 
-    Reads the :ref:`floorplanning constraints <vpr_constraints_file>` that packing and placement must respect from the specified XML file.
+    Reads the :ref:`floorplanning constraints <vpr_constraints_file>` that packing and placement must respect from the specified XML file; and/or reads the :ref:`global route constraints <vpr_constraints_file>` that router must respect from the specified XML file. Multiple files are allowed and should be seperated with a colomn char. 
 
 .. option:: --write_vpr_constraints <file>
 
-    Writes out new :ref:`floorplanning constraints <vpr_constraints_file>` based on current placement to the specified XML file.
+    Writes out new :ref:`floorplanning constraints <vpr_constraints_file>` based on current placement to the specified XML file; and/or writes out new :ref:`global route constraints <vpr_constraints_file>` based on current global routecounstraints to the specified XML file. Note that a single combined file is written to even there are multiple input constraint files read in.
 
 .. option:: --read_router_lookahead <file>
 

doc/src/vpr/route_constraints.rst

@@ -0,0 +1,39 @@
+
+VPR Placement Constraints
+=========================
+.. _vpr_constraints_file:
+VPR supports running flows with route constraints. Route constraints are set on global signals to specify if they should be routed or not. For example, a user may want to route a specific internal clock even clock modeling option is set to not route it.
+
+The route constraints should be specified by the user using an XML constraints file format, as described in the section below. 
+
+A Constraints File Example
+--------------------------
+
+.. code-block:: xml
+	:caption: An example of a route constraints file in XML format.
+	:linenos:
+
+	<vpr_constraints tool_name="vpr">
+                <global_route_constraints>
+                        <!-- specify route method for a global pin that needs to be connected globally -->
+                        <set_global_signal name="(int_clk)(.*)" type="clock" route_model="route"/>
+                        <set_global_signal name="clk_ni" type="clock" route_model="ideal"/>
+                </global_route_constraints>
+	</vpr_constraints>
+
+.. _end:
+
+Constraints File Format
+-----------------------
+
+VPR has a specific XML format which must be used when creating a route constraints file. The purpose of this constraints file is to specify 
+
+#. The signals that should be constrained for routing
+#. The route model for such signals 
+
+The file is passed as an input to VPR when running with route constraints. When the file is read in, its information is used to guide VPR route or not route such signals.
+
+.. note:: Use the VPR option :vpr:option:`--read_vpr_constraints` to specify the VPR route constraints file that is to be loaded. 
+
+.. note:: Wildcard names of signals are supported to specify a list of signals. The wildcard expression should follow the C/C++ regexpr rule.
+

vpr/src/base/gen/vpr_constraints_uxsdcxx_interface.h

@@ -4,9 +4,9 @@
  * https://github.com/duck2/uxsdcxx
  * Modify only if your build process doesn't involve regenerating this file.
  *
- * Cmdline: uxsdcxx.py vpr_constraints.xsd
- * Input file: /home/khalid88/Documents/uxsdcxx/vpr_constraints.xsd
- * md5sum of input file: 6b6011a6e6446347b234da82e517422e
+ * Cmdline: uxsdcxx.py /home/tao/works/dev/clock/vtr-verilog-to-routing/vpr/src/base/vpr_constraints.xsd
+ * Input file: /home/tao/works/dev/clock/vtr-verilog-to-routing/vpr/src/base/vpr_constraints.xsd
+ * md5sum of input file: 2d6f442d8044f76e8f1b1d276b7358da
  */
 
 #include <functional>
@@ -24,11 +24,15 @@ struct DefaultVprConstraintsContextTypes {
     using AddRegionReadContext = void*;
     using PartitionReadContext = void*;
     using PartitionListReadContext = void*;
+    using SetGlobalSignalReadContext = void*;
+    using GlobalRouteConstraintsReadContext = void*;
     using VprConstraintsReadContext = void*;
     using AddAtomWriteContext = void*;
     using AddRegionWriteContext = void*;
     using PartitionWriteContext = void*;
     using PartitionListWriteContext = void*;
+    using SetGlobalSignalWriteContext = void*;
+    using GlobalRouteConstraintsWriteContext = void*;
     using VprConstraintsWriteContext = void*;
 };
 
@@ -92,7 +96,7 @@ class VprConstraintsBase {
     /** Generated for complex type "partition_list":
      * <xs:complexType name="partition_list">
      *   <xs:sequence>
-     *     <xs:element maxOccurs="unbounded" name="partition" type="partition" />
+     *     <xs:element name="partition" type="partition" maxOccurs="unbounded" />
      *   </xs:sequence>
      * </xs:complexType>
      */
@@ -102,19 +106,54 @@ class VprConstraintsBase {
     virtual inline size_t num_partition_list_partition(typename ContextTypes::PartitionListReadContext& ctx) = 0;
     virtual inline typename ContextTypes::PartitionReadContext get_partition_list_partition(int n, typename ContextTypes::PartitionListReadContext& ctx) = 0;
 
+    /** Generated for complex type "set_global_signal":
+     * <xs:complexType name="set_global_signal">
+     *   <xs:attribute name="name" type="xs:string" use="required" />
+     *   <xs:attribute name="type" type="xs:string" use="required" />
+     *   <xs:attribute name="route_model" type="xs:string" use="required" />
+     * </xs:complexType>
+     */
+    virtual inline const char* get_set_global_signal_name(typename ContextTypes::SetGlobalSignalReadContext& ctx) = 0;
+    virtual inline void set_set_global_signal_name(const char* name, typename ContextTypes::SetGlobalSignalWriteContext& ctx) = 0;
+    virtual inline const char* get_set_global_signal_route_model(typename ContextTypes::SetGlobalSignalReadContext& ctx) = 0;
+    virtual inline void set_set_global_signal_route_model(const char* route_model, typename ContextTypes::SetGlobalSignalWriteContext& ctx) = 0;
+    virtual inline const char* get_set_global_signal_type(typename ContextTypes::SetGlobalSignalReadContext& ctx) = 0;
+    virtual inline void set_set_global_signal_type(const char* type, typename ContextTypes::SetGlobalSignalWriteContext& ctx) = 0;
+
+    /** Generated for complex type "global_route_constraints":
+     * <xs:complexType name="global_route_constraints">
+     *   <xs:sequence>
+     *     <xs:element name="set_global_signal" type="set_global_signal" maxOccurs="unbounded" />
+     *   </xs:sequence>
+     * </xs:complexType>
+     */
+    virtual inline void preallocate_global_route_constraints_set_global_signal(typename ContextTypes::GlobalRouteConstraintsWriteContext& ctx, size_t size) = 0;
+    virtual inline typename ContextTypes::SetGlobalSignalWriteContext add_global_route_constraints_set_global_signal(typename ContextTypes::GlobalRouteConstraintsWriteContext& ctx) = 0;
+    virtual inline void finish_global_route_constraints_set_global_signal(typename ContextTypes::SetGlobalSignalWriteContext& ctx) = 0;
+    virtual inline size_t num_global_route_constraints_set_global_signal(typename ContextTypes::GlobalRouteConstraintsReadContext& ctx) = 0;
+    virtual inline typename ContextTypes::SetGlobalSignalReadContext get_global_route_constraints_set_global_signal(int n, typename ContextTypes::GlobalRouteConstraintsReadContext& ctx) = 0;
+
     /** Generated for complex type "vpr_constraints":
      * <xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema">
-     *     <xs:all>
+     *     <xs:choice minOccurs="0" maxOccurs="unbounded">
      *       <xs:element name="partition_list" type="partition_list" />
-     *     </xs:all>
+     *       <xs:element name="global_route_constraints" type="global_route_constraints" />
+     *     </xs:choice>
      *     <xs:attribute name="tool_name" type="xs:string" />
      *   </xs:complexType>
      */
     virtual inline const char* get_vpr_constraints_tool_name(typename ContextTypes::VprConstraintsReadContext& ctx) = 0;
     virtual inline void set_vpr_constraints_tool_name(const char* tool_name, typename ContextTypes::VprConstraintsWriteContext& ctx) = 0;
-    virtual inline typename ContextTypes::PartitionListWriteContext init_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsWriteContext& ctx) = 0;
+    virtual inline void preallocate_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsWriteContext& ctx, size_t size) = 0;
+    virtual inline typename ContextTypes::PartitionListWriteContext add_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsWriteContext& ctx) = 0;
     virtual inline void finish_vpr_constraints_partition_list(typename ContextTypes::PartitionListWriteContext& ctx) = 0;
-    virtual inline typename ContextTypes::PartitionListReadContext get_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsReadContext& ctx) = 0;
+    virtual inline size_t num_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsReadContext& ctx) = 0;
+    virtual inline typename ContextTypes::PartitionListReadContext get_vpr_constraints_partition_list(int n, typename ContextTypes::VprConstraintsReadContext& ctx) = 0;
+    virtual inline void preallocate_vpr_constraints_global_route_constraints(typename ContextTypes::VprConstraintsWriteContext& ctx, size_t size) = 0;
+    virtual inline typename ContextTypes::GlobalRouteConstraintsWriteContext add_vpr_constraints_global_route_constraints(typename ContextTypes::VprConstraintsWriteContext& ctx) = 0;
+    virtual inline void finish_vpr_constraints_global_route_constraints(typename ContextTypes::GlobalRouteConstraintsWriteContext& ctx) = 0;
+    virtual inline size_t num_vpr_constraints_global_route_constraints(typename ContextTypes::VprConstraintsReadContext& ctx) = 0;
+    virtual inline typename ContextTypes::GlobalRouteConstraintsReadContext get_vpr_constraints_global_route_constraints(int n, typename ContextTypes::VprConstraintsReadContext& ctx) = 0;
 };
 
 } /* namespace uxsd */

vpr/src/base/route_constraint.cpp

@@ -0,0 +1,43 @@
+#include "route_constraint.h"
+
+RouteConstraint::RouteConstraint() {
+    net_name_ = std::string("");
+    net_type_ = std::string("");
+    route_method_ = std::string("");
+    is_valid_ = false;
+}
+
+void RouteConstraint::set_net_name(std::string name) {
+    net_name_ = name;
+    return;
+}
+
+std::string RouteConstraint::get_net_name() const {
+    return net_name_;
+}
+
+void RouteConstraint::set_net_type(std::string type) {
+    net_type_ = type;
+    return;
+}
+
+std::string RouteConstraint::get_net_type() const {
+    return net_type_;
+}
+
+void RouteConstraint::set_route_model(std::string route_method) {
+    route_method_ = route_method;
+    return;
+}
+
+std::string RouteConstraint::get_route_model() const {
+    return route_method_;
+}
+
+void RouteConstraint::set_is_valid(bool value) {
+    is_valid_ = value;
+}
+
+bool RouteConstraint::get_is_valid() const {
+    return is_valid_;
+}

vpr/src/base/route_constraint.h

@@ -0,0 +1,65 @@
+#ifndef ROUTE_CONSTRAINT_H
+#define ROUTE_CONSTRAINT_H
+
+#include "vpr_types.h"
+
+/**
+ * @file
+ * @brief This file defines the RouteConstraint class.
+ */
+
+class RouteConstraint {
+  public:
+    /**
+     * @brief Constructor for the RouteConstraint class, sets member variables to invalid values
+     */
+    RouteConstraint();
+
+    /**
+     * @brief get net name
+     */
+    std::string get_net_name() const;
+
+    /**
+     * @brief set net name
+     */
+    void set_net_name(std::string);
+
+    /**
+     * @brief get net type
+     */
+    std::string get_net_type() const;
+
+    /**
+     * @brief set net type
+     */
+    void set_net_type(std::string);
+
+    /**
+     * @brief get route model
+     */
+    std::string get_route_model() const;
+
+    /**
+     * @brief set route model
+     */
+    void set_route_model(std::string);
+
+    /**
+     * @brief set is valid 
+     */
+    void set_is_valid(bool);
+
+    /**
+     * @brief get is valid 
+     */
+    bool get_is_valid() const;
+
+  private:
+    std::string net_name_;
+    std::string net_type_;
+    std::string route_method_;
+    bool is_valid_;
+};
+
+#endif /* ROUTE_CONSTRAINT_H */

vpr/src/base/vpr_api.cpp

@@ -345,10 +345,15 @@ void vpr_init_with_options(const t_options* options, t_vpr_setup* vpr_setup, t_a
         }
     }
 
-    //Initialize vpr floorplanning constraints
+    //Initialize vpr floorplanning and routing constraints
     auto& filename_opts = vpr_setup->FileNameOpts;
     if (!filename_opts.read_vpr_constraints_file.empty()) {
-        load_vpr_constraints_file(filename_opts.read_vpr_constraints_file.c_str());
+        load_vpr_constraints_files(filename_opts.read_vpr_constraints_file.c_str());
+
+        // give a notificaiton on routing constraints overiding clock modeling
+        if (g_vpr_ctx.routing().constraints.get_route_constraint_num() && options->clock_modeling.provenance() == argparse::Provenance::SPECIFIED) {
+            VTR_LOG_WARN("Route constraint(s) detected and will override clock modeling setting.\n");
+        }
     }
 
     fflush(stdout);
@@ -398,6 +403,9 @@ bool vpr_flow(t_vpr_setup& vpr_setup, t_arch& arch) {
         vpr_analysis_flow(router_net_list, vpr_setup, arch, route_status, is_flat);
     }
 
+    // write out constratins
+    write_vpr_constraints(vpr_setup);
+
     //close the graphics
     vpr_close_graphics(vpr_setup);
 
@@ -779,6 +787,11 @@ RouteStatus vpr_route_flow(const Netlist<>& net_list,
         //Assume successful
         route_status = RouteStatus(true, -1);
     } else { //Do or load
+
+        // apply route constraints
+        // use mutable routing context here to apply change on the constraints when binding the constraint to real net
+        apply_route_constraints(g_vpr_ctx.mutable_routing().constraints);
+
         int chan_width = router_opts.fixed_channel_width;
 
         NetPinsMatrix<float> net_delay;

vpr/src/base/vpr_constraints.cpp

@@ -1,5 +1,7 @@
 #include "vpr_constraints.h"
 #include "partition.h"
+#include "route_constraint.h"
+#include <regex>
 
 void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const PartitionId part_id) {
     auto got = constrained_atoms.find(blk_id);
@@ -58,6 +60,70 @@ PartitionRegion VprConstraints::get_partition_pr(PartitionId part_id) {
     return pr;
 }
 
+void VprConstraints::add_route_constraint(RouteConstraint rc) {
+    route_constraints_.insert({rc.get_net_name(), rc});
+    return;
+}
+
+RouteConstraint VprConstraints::get_route_constraint_by_net_name(std::string net_name) {
+    RouteConstraint rc;
+    auto const& rc_itr = route_constraints_.find(net_name);
+    if (rc_itr == route_constraints_.end()) {
+        // try regexp
+        bool found_thru_regex = false;
+        for (auto constraint : route_constraints_) {
+            if (std::regex_match(net_name, std::regex(constraint.first))) {
+                {
+                    rc = constraint.second;
+
+                    // mark as invalid so write constraint function will not write constraint
+                    // of regexpr name
+                    // instead a matched constraint is inserted in
+                    constraint.second.set_is_valid(false);
+                    rc.set_net_name(net_name);
+                    rc.set_is_valid(true);
+                    route_constraints_.insert({net_name, rc});
+
+                    found_thru_regex = true;
+                    break;
+                }
+            }
+        }
+        if (!found_thru_regex) {
+            rc.set_net_name("INVALID");
+            rc.set_net_type("INVALID");
+            rc.set_route_model("INVALID");
+            rc.set_is_valid(false);
+        }
+    } else {
+        rc = rc_itr->second;
+    }
+    return rc;
+}
+
+RouteConstraint VprConstraints::get_route_constraint_by_idx(std::size_t idx) const {
+    RouteConstraint rc;
+    if ((route_constraints_.size() == 0) || (idx > route_constraints_.size() - 1)) {
+        rc.set_net_name("INVALID");
+        rc.set_net_type("INVALID");
+        rc.set_route_model("INVALID");
+        rc.set_is_valid(false);
+    } else {
+        std::size_t i = 0;
+        for (auto const& rc_itr : route_constraints_) {
+            if (i == idx) {
+                rc = rc_itr.second;
+                break;
+            }
+        }
+    }
+    return rc;
+}
+
+int VprConstraints::get_route_constraint_num(void) const {
+    return route_constraints_.size();
+}
+
 void print_constraints(FILE* fp, VprConstraints constraints) {
     Partition temp_part;
     std::vector<AtomBlockId> atoms;