add create rr_graph_obj function which loads rr_nodes to the object

tangxifan · tangxifan · commit 62ede3ac1a9d · 2019-11-20T16:51:38.000-07:00
diff --git a/libs/libvtrutil/src/vtr_geometry.h b/libs/libvtrutil/src/vtr_geometry.h
@@ -48,6 +48,7 @@ template<class T>
 class Point {
   public: //Constructors
     Point(T x_val, T y_val) noexcept;
+    Point();
 
   public: //Accessors
     //Coordinates
diff --git a/libs/libvtrutil/src/vtr_geometry.tpp b/libs/libvtrutil/src/vtr_geometry.tpp
@@ -10,6 +10,11 @@ Point<T>::Point(T x_val, T y_val) noexcept
     //pass
 }
 
+template<class T>
+Point<T>::Point() {
+    //pass
+}
+
 template<class T>
 T Point<T>::x() const {
     return x_;
@@ -74,6 +79,11 @@ Rect<T>::Rect(Point<T> bottom_left_val, Point<T> top_right_val)
     //pass
 }
 
+template<class T>
+Rect<T>::Rect() {
+    //pass
+}
+
 template<class T>
 T Rect<T>::xmin() const {
     return bottom_left_.x();
diff --git a/vpr/src/base/vpr_context.h b/vpr/src/base/vpr_context.h
@@ -21,6 +21,7 @@
 #include "router_lookahead.h"
 #include "place_macro.h"
 #include "compressed_grid.h"
+#include "rr_graph_obj.h"
 
 //A Context is collection of state relating to a particular part of VPR
 //
@@ -136,6 +137,9 @@ struct DeviceContext : public Context {
     /* chan_width is for x|y-directed channels; i.e. between rows */
     t_chan_width chan_width;
 
+    /* Object to define routing resources */
+    RRGraph rr_graph;
+
     /* Structures to define the routing architecture of the FPGA.           */
     std::vector<t_rr_node> rr_nodes; /* autogenerated in build_rr_graph */
 
diff --git a/vpr/src/device/check_rr_graph_obj.cpp b/vpr/src/device/check_rr_graph_obj.cpp
@@ -107,7 +107,7 @@ static bool check_rr_graph_source_nodes(const RRGraph& rr_graph) {
         }
     }
 
-    return invalid_sources;
+    return !invalid_sources;
 }
 
 /*********************************************************************** 
@@ -136,7 +136,7 @@ static bool check_rr_graph_sink_nodes(const RRGraph& rr_graph) {
         }
     }
 
-    return invalid_sinks;
+    return !invalid_sinks;
 }
 
 /*********************************************************************** 
@@ -153,48 +153,43 @@ static bool check_rr_graph_sink_nodes(const RRGraph& rr_graph) {
  * will work properly.
  **********************************************************************/
 bool check_rr_graph(const RRGraph& rr_graph) {
-    bool check_flag = true;
     size_t num_err = 0;
 
     if (false == check_rr_graph_duplicated_edges(rr_graph)) {
         VTR_LOG_WARN("Fail in checking duplicated edges !\n");
-        check_flag = false;
         num_err++;
     }
 
     if (false == check_rr_graph_dangling_nodes(rr_graph)) {
         VTR_LOG_WARN("Fail in checking dangling nodes !\n");
-        check_flag = false;
         num_err++;
     }
 
     if (false == check_rr_graph_source_nodes(rr_graph)) {
         VTR_LOG_WARN("Fail in checking source nodes!\n");
-        check_flag = false;
         num_err++;
     }
 
     if (false == check_rr_graph_sink_nodes(rr_graph)) {
         VTR_LOG_WARN("Fail in checking sink nodes!\n");
-        check_flag = false;
         num_err++;
     }
 
     if (false == check_rr_graph_source_nodes(rr_graph)) {
         VTR_LOG_WARN("Fail in checking source nodes!\n");
-        check_flag = false;
         num_err++;
     }
 
     if (false == check_rr_graph_sink_nodes(rr_graph)) {
         VTR_LOG_WARN("Fail in checking sink nodes!\n");
-        check_flag = false;
         num_err++;
     }
 
     /* Error out if there is any fatal errors found */
-    VTR_LOG_WARN("Checked Routing Resource graph with %d errors !\n",
-                 num_err);
+    if (0 < num_err) {
+        VTR_LOG_WARN("Checked Routing Resource graph with %d errors !\n",
+                     num_err);
+    }
 
-    return check_flag;
+    return (0 == num_err);
 }
diff --git a/vpr/src/device/create_rr_graph.cpp b/vpr/src/device/create_rr_graph.cpp
@@ -0,0 +1,149 @@
+/* Standard header files required go first */
+#include <map>
+
+/* EXTERNAL library header files go second*/
+#include "vtr_assert.h"
+#include "vtr_time.h"
+
+/* VPR header files go then */
+#include "vpr_types.h"
+#include "rr_graph_obj.h"
+#include "check_rr_graph_obj.h"
+#include "create_rr_graph.h"
+
+/* Finally we include global variables */
+#include "globals.h"
+
+/********************************************************************
+ * TODO: remove when this conversion (from traditional to new data structure)
+ * is no longer needed
+ * This function will convert an existing rr_graph in device_ctx to the RRGraph
+ *object
+ * This function is used to test our RRGraph if it is acceptable in downstream
+ *routers
+ ********************************************************************/
+void convert_rr_graph(std::vector<t_segment_inf>& vpr_segments) {
+    vtr::ScopedStartFinishTimer timer("Build routing resource graph object");
+
+    /* IMPORTANT: to build clock tree,
+     * vpr added segments to the original arch segments
+     * This is why to use vpr_segments as an inputs!!!
+     */
+    auto& device_ctx = g_vpr_ctx.mutable_device();
+
+    /* make sure we have a clean empty rr_graph */
+    device_ctx.rr_graph.clear();
+
+    /* The number of switches are in general small,
+     * reserve switches may not bring significant memory efficiency
+     * So, we just use create_switch to push_back each time
+     */
+    device_ctx.rr_graph.reserve_switches(device_ctx.rr_switch_inf.size());
+    // Create the switches
+    for (size_t iswitch = 0; iswitch < device_ctx.rr_switch_inf.size(); ++iswitch) {
+        device_ctx.rr_graph.create_switch(device_ctx.rr_switch_inf[iswitch]);
+    }
+
+    /* The number of segments are in general small, reserve segments may not bring
+     * significant memory efficiency */
+    device_ctx.rr_graph.reserve_segments(vpr_segments.size());
+    // Create the segments
+    for (size_t iseg = 0; iseg < vpr_segments.size(); ++iseg) {
+        device_ctx.rr_graph.create_segment(vpr_segments[iseg]);
+    }
+
+    /* Reserve list of nodes to be memory efficient */
+    device_ctx.rr_graph.reserve_nodes(device_ctx.rr_nodes.size());
+
+    // Create the nodes
+    std::map<int, RRNodeId> old_to_new_rr_node;
+    for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); ++inode) {
+        auto& node = device_ctx.rr_nodes[inode];
+        RRNodeId rr_node = device_ctx.rr_graph.create_node(node.type());
+
+        device_ctx.rr_graph.set_node_xlow(rr_node, node.xlow());
+        device_ctx.rr_graph.set_node_ylow(rr_node, node.ylow());
+        device_ctx.rr_graph.set_node_xhigh(rr_node, node.xhigh());
+        device_ctx.rr_graph.set_node_yhigh(rr_node, node.yhigh());
+
+        device_ctx.rr_graph.set_node_capacity(rr_node, node.capacity());
+
+        device_ctx.rr_graph.set_node_ptc_num(rr_node, node.ptc_num());
+
+        device_ctx.rr_graph.set_node_cost_index(rr_node, node.cost_index());
+
+        if (CHANX == node.type() || CHANY == node.type()) {
+            device_ctx.rr_graph.set_node_direction(rr_node, node.direction());
+        }
+        if (IPIN == node.type() || OPIN == node.type()) {
+            device_ctx.rr_graph.set_node_side(rr_node, node.side());
+        }
+        device_ctx.rr_graph.set_node_R(rr_node, node.R());
+        device_ctx.rr_graph.set_node_C(rr_node, node.C());
+
+        /* Set up segment id */
+        short irc_data = node.cost_index();
+        short iseg = device_ctx.rr_indexed_data[irc_data].seg_index;
+        device_ctx.rr_graph.set_node_segment(rr_node, RRSegmentId(iseg));
+
+        VTR_ASSERT(!old_to_new_rr_node.count(inode));
+        old_to_new_rr_node[inode] = rr_node;
+    }
+
+    /* Reserve list of edges to be memory efficient */
+    {
+        int num_edges_to_reserve = 0;
+        for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); ++inode) {
+            const auto& node = device_ctx.rr_nodes[inode];
+            num_edges_to_reserve += node.num_edges();
+        }
+        device_ctx.rr_graph.reserve_edges(num_edges_to_reserve);
+    }
+
+    // Create the edges
+    std::map<std::pair<int, int>, RREdgeId> old_to_new_rr_edge; // Key:
+                                                                // {inode,iedge}
+    for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); ++inode) {
+        const auto& node = device_ctx.rr_nodes[inode];
+        for (int iedge = 0; iedge < node.num_edges(); ++iedge) {
+            int isink_node = node.edge_sink_node(iedge);
+            int iswitch = node.edge_switch(iedge);
+
+            VTR_ASSERT(old_to_new_rr_node.count(inode));
+            VTR_ASSERT(old_to_new_rr_node.count(isink_node));
+
+            RREdgeId rr_edge = device_ctx.rr_graph.create_edge(old_to_new_rr_node[inode],
+                                                               old_to_new_rr_node[isink_node],
+                                                               RRSwitchId(iswitch));
+
+            auto key = std::make_pair(inode, iedge);
+            VTR_ASSERT(!old_to_new_rr_edge.count(key));
+            old_to_new_rr_edge[key] = rr_edge;
+        }
+    }
+
+    /* Partition edges to be two class: configurable (1st part) and
+     * non-configurable (2nd part)
+     * See how the router will use the edges and determine the strategy
+     * if we want to partition the edges first or depends on the routing needs
+     */
+    device_ctx.rr_graph.partition_edges();
+
+    /* Essential check for rr_graph, build look-up and  */
+    if (false == device_ctx.rr_graph.validate()) {
+        /* Error out if built-in validator of rr_graph fails */
+        vpr_throw(VPR_ERROR_ROUTE,
+                  __FILE__,
+                  __LINE__,
+                  "Fundamental errors occurred when validating rr_graph object!\n");
+    }
+
+    /* Error out if advanced checker of rr_graph fails */
+    if (false == check_rr_graph(device_ctx.rr_graph)) {
+        vpr_throw(VPR_ERROR_ROUTE,
+                  __FILE__,
+                  __LINE__,
+                  "Advanced checking rr_graph object fails! Routing may still work "
+                  "but not smooth\n");
+    }
+}
diff --git a/vpr/src/device/create_rr_graph.h b/vpr/src/device/create_rr_graph.h
@@ -0,0 +1,17 @@
+#ifndef CREATE_RR_GRAPH_H
+#define CREATE_RR_GRAPH_H
+
+/*
+ * Notes in include header files in a head file 
+ * Only include the neccessary header files 
+ * that is required by the data types in the function/class declarations!
+ */
+#include "rr_graph_obj.h"
+
+/* IMPORTANT: to build clock tree,
+ * vpr added segments to the original arch segments  
+ * This is why to use vpr_segments as an inputs!!!
+ */
+void convert_rr_graph(std::vector<t_segment_inf>& vpr_segments);
+
+#endif
diff --git a/vpr/src/device/rr_graph_obj.cpp b/vpr/src/device/rr_graph_obj.cpp
@@ -714,7 +714,6 @@ bool RRGraph::validate_edge_sink_nodes() const {
  * Warnings are thrown if optional checking fails
  */
 bool RRGraph::validate() const {
-    bool check_flag = true;
     size_t num_err = 0;
 
     initialize_fast_node_lookup();
@@ -724,34 +723,32 @@ bool RRGraph::validate() const {
      */
     if (false == validate_sizes()) {
         VTR_LOG_WARN("Fail in validating node- and edge-related vector sizes!\n");
-        check_flag = false;
         num_err++;
     }
 
     /* Fundamental check */
     if (false == validate_nodes_edges()) {
         VTR_LOG_WARN("Fail in validating edges connected to each node!\n");
-        check_flag = false;
         num_err++;
     }
 
     if (false == validate_node_segments()) {
         VTR_LOG_WARN("Fail in validating segment IDs of nodes !\n");
-        check_flag = false;
         num_err++;
     }
 
     if (false == validate_edge_switches()) {
         VTR_LOG_WARN("Fail in validating switch IDs of edges !\n");
-        check_flag = false;
         num_err++;
     }
 
     /* Error out if there is any fatal errors found */
-    VTR_LOG_ERROR("Routing Resource graph is not valid due to %d fatal errors !\n",
-                  num_err);
+    if (0 < num_err) {
+        VTR_LOG_ERROR("Routing Resource graph is not valid due to %d fatal errors !\n",
+                      num_err);
+    }
 
-    return check_flag;
+    return (0 == num_err);
 }
 
 bool RRGraph::is_dirty() const {
@@ -827,6 +824,7 @@ RRNodeId RRGraph::create_node(const t_rr_type& type) {
     node_sides_.push_back(NUM_SIDES);
     node_Rs_.push_back(0.);
     node_Cs_.push_back(0.);
+    node_segments_.push_back(RRSegmentId::INVALID());
 
     node_in_edges_.emplace_back();  //Initially empty
     node_out_edges_.emplace_back(); //Initially empty
diff --git a/vpr/src/route/rr_graph.cpp b/vpr/src/route/rr_graph.cpp
@@ -33,6 +33,7 @@
 #include "rr_graph_reader.h"
 #include "router_lookahead_map.h"
 #include "rr_graph_clock.h"
+#include "create_rr_graph.h"
 
 #include "rr_types.h"
 
@@ -375,6 +376,9 @@ void create_rr_graph(const t_graph_type graph_type,
 
     print_rr_graph_stats();
 
+    /* Create rr_graph object: load rr_nodes to the object */
+    convert_rr_graph(segment_inf);
+
     //Write out rr graph file if needed
     if (!det_routing_arch->write_rr_graph_filename.empty()) {
         write_rr_graph(det_routing_arch->write_rr_graph_filename.c_str(), segment_inf);
diff --git a/vpr/src/util/rr_graph_obj_util.cpp b/vpr/src/util/rr_graph_obj_util.cpp
@@ -0,0 +1,30 @@
+/****************************************************************************
+ * This file include most-utilized functions that manipulate on the
+ * RRGraph object
+ ***************************************************************************/
+#include <tuple>
+#include "rr_graph_obj_util.h"
+
+/****************************************************************************
+ * Find the switches interconnecting two nodes
+ * Return a vector of switch ids
+ ***************************************************************************/
+std::vector<RRSwitchId> find_rr_graph_switches(const RRGraph& rr_graph,
+                                               const RRNodeId& from_node,
+                                               const RRNodeId& to_node) {
+    std::vector<RRSwitchId> switches;
+    std::vector<RREdgeId> edges = rr_graph.find_edges(from_node, to_node);
+    if (true == edges.empty()) {
+        /* edge is open, we return an empty vector of switches */
+        return switches;
+    }
+
+    /* Reach here, edge list is not empty, find switch id one by one
+     * and update the switch list
+     */
+    for (auto edge : edges) {
+        switches.push_back(rr_graph.edge_switch(edge));
+    }
+
+    return switches;
+}
diff --git a/vpr/src/util/rr_graph_obj_util.h b/vpr/src/util/rr_graph_obj_util.h
diff --git a/vpr/src/util/rr_graph_obj_utils.h b/vpr/src/util/rr_graph_obj_utils.h

Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ static bool check_rr_graph_source_nodes(const RRGraph& rr_graph) {`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`
`110`		`- return invalid_sources;`
	`110`	`+ return !invalid_sources;`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`/***********************************************************************`
`@@ -136,7 +136,7 @@ static bool check_rr_graph_sink_nodes(const RRGraph& rr_graph) {`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`		`- return invalid_sinks;`
	`139`	`+ return !invalid_sinks;`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`/***********************************************************************`
`@@ -153,48 +153,43 @@ static bool check_rr_graph_sink_nodes(const RRGraph& rr_graph) {`
`153`	`153`	`* will work properly.`
`154`	`154`	`**********************************************************************/`
`155`	`155`	`bool check_rr_graph(const RRGraph& rr_graph) {`
`156`		`- bool check_flag = true;`
`157`	`156`	`size_t num_err = 0;`
`158`	`157`
`159`	`158`	`if (false == check_rr_graph_duplicated_edges(rr_graph)) {`
`160`	`159`	`VTR_LOG_WARN("Fail in checking duplicated edges !\n");`
`161`		`- check_flag = false;`
`162`	`160`	`num_err++;`
`163`	`161`	`}`
`164`	`162`
`165`	`163`	`if (false == check_rr_graph_dangling_nodes(rr_graph)) {`
`166`	`164`	`VTR_LOG_WARN("Fail in checking dangling nodes !\n");`
`167`		`- check_flag = false;`
`168`	`165`	`num_err++;`
`169`	`166`	`}`
`170`	`167`
`171`	`168`	`if (false == check_rr_graph_source_nodes(rr_graph)) {`
`172`	`169`	`VTR_LOG_WARN("Fail in checking source nodes!\n");`
`173`		`- check_flag = false;`
`174`	`170`	`num_err++;`
`175`	`171`	`}`
`176`	`172`
`177`	`173`	`if (false == check_rr_graph_sink_nodes(rr_graph)) {`
`178`	`174`	`VTR_LOG_WARN("Fail in checking sink nodes!\n");`
`179`		`- check_flag = false;`
`180`	`175`	`num_err++;`
`181`	`176`	`}`
`182`	`177`
`183`	`178`	`if (false == check_rr_graph_source_nodes(rr_graph)) {`
`184`	`179`	`VTR_LOG_WARN("Fail in checking source nodes!\n");`
`185`		`- check_flag = false;`
`186`	`180`	`num_err++;`
`187`	`181`	`}`
`188`	`182`
`189`	`183`	`if (false == check_rr_graph_sink_nodes(rr_graph)) {`
`190`	`184`	`VTR_LOG_WARN("Fail in checking sink nodes!\n");`
`191`		`- check_flag = false;`
`192`	`185`	`num_err++;`
`193`	`186`	`}`
`194`	`187`
`195`	`188`	`/* Error out if there is any fatal errors found */`
`196`		`- VTR_LOG_WARN("Checked Routing Resource graph with %d errors !\n",`
`197`		`- num_err);`
	`189`	`+ if (0 < num_err) {`
	`190`	`+ VTR_LOG_WARN("Checked Routing Resource graph with %d errors !\n",`
	`191`	`+ num_err);`
	`192`	`+ }`
`198`	`193`
`199`		`- return check_flag;`
	`194`	`+ return (0 == num_err);`
`200`	`195`	`}`