RR Graph Overlay Creation and Deploy new node_type() API of Overlay

vpr/src/base/vpr_context.h

@@ -9,7 +9,9 @@
 #include "vtr_vector.h"
 #include "atom_netlist.h"
 #include "clustered_netlist.h"
+#include "rr_graph_view.h"
 #include "rr_graph_storage.h"
+#include "rr_graph_builder.h"
 #include "rr_node.h"
 #include "rr_rc_data.h"
 #include "tatum/TimingGraph.hpp"
@@ -145,7 +147,6 @@ struct DeviceContext : public Context {
     /*
      * Structures to define the routing architecture of the FPGA.
      */
-
     t_rr_graph_storage rr_nodes; // autogenerated in build_rr_graph
 
     std::vector<t_rr_indexed_data> rr_indexed_data; // [0 .. num_rr_indexed_data-1]
@@ -162,6 +163,21 @@ struct DeviceContext : public Context {
     ///@brief The indicies of rr nodes of a given type at a specific x,y grid location
     t_rr_node_indices rr_node_indices; // [0..NUM_RR_TYPES-1][0..grid.width()-1][0..grid.width()-1][0..size-1]
 
+    /* TODO: remove this interface from device_context once the code refactoring is completed
+     * because it should be part of the rr_graph view
+     */
+    RRSpatialLookup rr_spatial_lookup{rr_node_indices};
+
+    /* A read-only view of routing resource graph to be the ONLY database 
+     * for client functions: GUI, placer, router, timing analyzer etc.
+     */
+    RRGraphView rr_graph{rr_nodes, rr_spatial_lookup};
+
+    /* A writeable view of routing resource graph to be the ONLY database 
+     * for routing resource graph builder functions.
+     */
+    RRGraphBuilder rr_graph_builder{&rr_nodes, &rr_spatial_lookup};
+
     ///@brief Autogenerated in build_rr_graph based on switch fan-in. [0..(num_rr_switches-1)]
     std::vector<t_rr_switch_inf> rr_switch_inf;
 

vpr/src/device/rr_graph_builder.cpp

@@ -0,0 +1,24 @@
+/***************************************
+ * Methods for Object RRGraphBuilder
+ ***************************************/
+#include "rr_graph_builder.h"
+
+/****************************
+ * Constructors
+ ****************************/
+RRGraphBuilder::RRGraphBuilder(t_rr_graph_storage* node_storage,
+                               RRSpatialLookup* node_lookup)
+    : node_storage_(*node_storage)
+    , node_lookup_(*node_lookup) {
+}
+
+/****************************
+ * Mutators
+ ****************************/
+t_rr_graph_storage& RRGraphBuilder::node_storage() {
+    return node_storage_;
+}
+
+RRSpatialLookup& RRGraphBuilder::node_lookup() {
+    return node_lookup_;
+}

vpr/src/device/rr_graph_builder.h

@@ -0,0 +1,63 @@
+#ifndef RR_GRAPH_BUILDER_H
+#define RR_GRAPH_BUILDER_H
+
+#include "rr_graph_storage.h"
+#include "rr_spatial_lookup.h"
+
+/* A data structure allows data modification on a routing resource graph 
+ *
+ * Note that the builder does not own the storage
+ * It serves a virtual protocol for
+ * - node_storage: store the node list 
+ * - node_lookup: store a fast look-up for the nodes
+ *
+ * Note:
+ * - This is the only data structre allowed to modify a routing resource graph
+ *
+ */
+class RRGraphBuilder {
+    /****************
+     * Constructors
+     ****************/
+  public:
+    RRGraphBuilder(t_rr_graph_storage* node_storage,
+                   RRSpatialLookup* node_lookup);
+
+    /* Disable copy constructors
+     * This is to avoid any duplication of the object
+     * as it is only interface allowed to modify routing resource graph
+     */
+    RRGraphBuilder(const RRGraphBuilder&) = delete;
+
+    /* Disable copy assignment operator */
+    void operator=(const RRGraphBuilder&) = delete;
+
+    /****************
+     * Mutators
+     ****************/
+  public:
+    /* Return a writable object for rr_nodes */
+    t_rr_graph_storage& node_storage();
+    /* Return a writable object for update the fast look-up of rr_node */
+    RRSpatialLookup& node_lookup();
+
+    /****************
+     * internal data storage
+     ****************/
+  private:
+    /* TODO: When the refactoring effort finishes, 
+     * the builder data structure will be the owner of the data storages. 
+     * That is why the reference to storage/lookup is used here.
+     * It can avoid a lot of code changes once the refactoring is finished 
+     * (there is no function get data directly through the node_storage in DeviceContext).
+     * If pointers are used, it may cause many codes in client functions 
+     * or inside the data structures to be changed later.
+     * That explains why the reference is used here temporarily
+     */
+    /* node-level storage including edge storages */
+    t_rr_graph_storage& node_storage_;
+    /* Fast look-up for rr nodes */
+    RRSpatialLookup& node_lookup_;
+};
+
+#endif

vpr/src/device/rr_graph_view.cpp

@@ -0,0 +1,25 @@
+/***************************************
+ * Methods for Object RRGraphView
+ ***************************************/
+#include "rr_graph_view.h"
+
+/****************************
+ * Constructors
+ ****************************/
+RRGraphView::RRGraphView(const t_rr_graph_storage& node_storage,
+                         const RRSpatialLookup& node_lookup)
+    : node_storage_(node_storage)
+    , node_lookup_(node_lookup) {
+}
+
+/****************************
+ * Accessors
+ ****************************/
+t_rr_type RRGraphView::node_type(RRNodeId node) const {
+    return node_storage_.node_type(node);
+}
+
+const RRSpatialLookup& RRGraphView::node_lookup() const {
+    /* Return a constant object rather than a writable one */
+    return node_lookup_;
+}

vpr/src/device/rr_graph_view.h

@@ -0,0 +1,71 @@
+#ifndef RR_GRAPH_VIEW_H
+#define RR_GRAPH_VIEW_H
+
+#include "rr_graph_storage.h"
+#include "rr_spatial_lookup.h"
+
+/* An read-only routing resource graph
+ * which is an unified object including pointors to
+ * - node storage
+ * - TODO: edge_storage
+ * - TODO: node_ptc_storage
+ * - TODO: node_fan_in_storage
+ * - rr_node_indices
+ *
+ * Note that the RRGraphView does not own the storage
+ * It serves a virtual read-only protocol for
+ * - placer
+ * - router
+ * - timing analyzer
+ * - GUI
+ *
+ * Note that each client of rr_graph may get a frame view of the object
+ * The RRGraphView is the complete frame view of the routing resource graph
+ * - This helps to reduce the memory footprint for each client
+ * - This avoids massive changes for each client on using the APIs
+ *   as each frame view provides adhoc APIs for each client
+ *
+ * TODO: more compact frame views will be created, e.g., 
+ * - a mini frame view: contains only node and edges, representing the connectivity of the graph
+ * - a geometry frame view: an extended mini frame view with node-level attributes, 
+ *                          in particular geometry information (type, x, y etc).
+ *
+ */
+class RRGraphView {
+    /****************
+     * Constructors
+     ****************/
+  public:
+    RRGraphView(const t_rr_graph_storage& node_storage,
+                const RRSpatialLookup& node_lookup);
+
+    /* Disable copy constructors
+     * This is to avoid any duplication of the object
+     * as it is only interface allowed to access routing resource graph
+     */
+    RRGraphView(const RRGraphView&) = delete;
+
+    /* Disable copy assignment operator */
+    void operator=(const RRGraphView&) = delete;
+
+    /****************
+     * Accessors
+     ****************/
+  public:
+    /* Get the type of a routing resource node */
+    t_rr_type node_type(RRNodeId node) const;
+
+    /* Return a read-only object for performing fast look-up in rr_node */
+    const RRSpatialLookup& node_lookup() const;
+
+    /****************
+     * internal data storage
+     ****************/
+  private:
+    /* node-level storage including edge storages */
+    const t_rr_graph_storage& node_storage_;
+    /* Fast look-up for rr nodes */
+    const RRSpatialLookup& node_lookup_;
+};
+
+#endif

vpr/src/device/rr_spatial_lookup.cpp

@@ -0,0 +1,108 @@
+/***************************************
+ * Methods for Object RRSpatialLookup
+ ***************************************/
+#include "vtr_assert.h"
+#include "rr_spatial_lookup.h"
+
+/****************************
+ * Constructors
+ ****************************/
+RRSpatialLookup::RRSpatialLookup(t_rr_node_indices& rr_node_indices)
+    : rr_node_indices_(rr_node_indices) {
+}
+
+/****************************
+ * Accessors
+ ****************************/
+RRNodeId RRSpatialLookup::find_node(int x,
+                                    int y,
+                                    t_rr_type type,
+                                    int ptc,
+                                    e_side side) const {
+    /* Find actual side to be used */
+    e_side node_side = side;
+    if (type == IPIN || type == OPIN) {
+        VTR_ASSERT_MSG(side != NUM_SIDES, "IPIN/OPIN must specify desired side (can not be default NUM_SIDES)");
+    } else {
+        VTR_ASSERT(type != IPIN && type != OPIN);
+        node_side = SIDES[0];
+    }
+
+    /* Currently need to swap x and y for CHANX because of chan, seg convention */
+    size_t node_x = x;
+    size_t node_y = y;
+    if (CHANX == type) {
+        std::swap(node_x, node_y);
+    }
+
+    VTR_ASSERT_SAFE(3 == rr_node_indices_[type].ndims());
+
+    /* Sanity check to ensure the x, y, side and ptc are in range 
+     * Data type of rr_node_indice:
+     *   typedef std::array<vtr::NdMatrix<std::vector<int>, 3>, NUM_RR_TYPES> t_rr_node_indices;
+     * Note that x, y and side are the 1st, 2nd and 3rd dimensions of the vtr::NdMatrix
+     * ptc is in the std::vector<int>
+     */
+    if (size_t(type) >= rr_node_indices_.size()) {
+        /* Node type is out of range, return an invalid index */
+        return RRNodeId::INVALID();
+    }
+
+    if (node_x >= rr_node_indices_[type].dim_size(0)) {
+        /* Node x is out of range, return an invalid index */
+        return RRNodeId::INVALID();
+    }
+
+    if (node_y >= rr_node_indices_[type].dim_size(1)) {
+        /* Node y is out of range, return an invalid index */
+        return RRNodeId::INVALID();
+    }
+
+    if (node_side >= rr_node_indices_[type].dim_size(2)) {
+        /* Node side is out of range, return an invalid index */
+        return RRNodeId::INVALID();
+    }
+
+    if (size_t(ptc) >= rr_node_indices_[type][node_x][node_y][node_side].size()) {
+        /* Ptc is out of range, return an invalid index */
+        return RRNodeId::INVALID();
+    }
+
+    /* Reaching here, it means that node exists in the look-up, return the id */
+    return RRNodeId(rr_node_indices_[type][node_x][node_y][node_side][ptc]);
+}
+
+/****************************
+ * Mutators
+ ****************************/
+void RRSpatialLookup::add_node(RRNodeId node,
+                               int x,
+                               int y,
+                               t_rr_type type,
+                               int ptc,
+                               e_side side) {
+    VTR_ASSERT_SAFE(3 == rr_node_indices_[type].ndims());
+
+    /* Expand the fast look-up if the new node is out-of-range
+     * This may seldom happen because the rr_graph building function
+     * should ensure the fast look-up well organized  
+     */
+    VTR_ASSERT(type < rr_node_indices_.size());
+    VTR_ASSERT(0 <= x);
+    VTR_ASSERT(0 <= y);
+
+    if ((x >= int(rr_node_indices_[type].dim_size(0)))
+        || (y >= int(rr_node_indices_[type].dim_size(1)))
+        || (size_t(side) >= rr_node_indices_[type].dim_size(2))) {
+        rr_node_indices_[type].resize({std::max(rr_node_indices_[type].dim_size(0), size_t(x) + 1),
+                                       std::max(rr_node_indices_[type].dim_size(1), size_t(y) + 1),
+                                       std::max(rr_node_indices_[type].dim_size(2), size_t(side) + 1)});
+    }
+
+    if (size_t(ptc) >= rr_node_indices_[type][x][y][side].size()) {
+        rr_node_indices_[type][x][y][side].resize(ptc + 1);
+    }
+
+    /* Resize on demand finished; Register the node */
+    rr_node_indices_[type][x][y][side][ptc] = int(size_t(node));
+}