Add new RouteTreeNode

Author: duck2

libs/libvtrutil/src/tl_optional.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+/* std::optional with optional refs.
+ * currently: import TartanLlama's optional into the vtr namespace
+ * documentation at https://tl.tartanllama.xyz/en/latest/api/optional.html */
+
+#include "tl_optional.hpp"
+
+namespace vtr {
+template<class T>
+using optional = tl::optional<T>;
+
+using nullopt_t = tl::nullopt_t;
+static constexpr nullopt_t nullopt = tl::nullopt;
+
+using bad_optional_access = tl::bad_optional_access;
+}

libs/libvtrutil/src/vtr_optional.h

@@ -619,31 +619,29 @@ void FasmWriterVisitor::check_for_lut(const t_pb* atom) {
 }
 
 void FasmWriterVisitor::visit_atom_impl(const t_pb* atom) {
-  check_for_lut(atom);
-  check_for_param(atom);
+    check_for_lut(atom);
+    check_for_param(atom);
 }
 
-void FasmWriterVisitor::walk_route_tree(const RRGraphBuilder& rr_graph_builder, const t_rt_node *root) {
-    for (t_linked_rt_edge* edge = root->u.child_list; edge != nullptr; edge = edge->next) {
-        auto *meta = vpr::rr_edge_metadata(rr_graph_builder, root->inode, edge->child->inode, edge->iswitch, fasm_features);
+void FasmWriterVisitor::walk_route_tree(const RRGraphBuilder& rr_graph_builder, const RouteTreeNode& root) {
+    for(auto& child: root.child_nodes()){
+        auto* meta = vpr::rr_edge_metadata(rr_graph_builder, size_t(root.inode), size_t(child.inode), size_t(child.parent_switch), fasm_features);
+
         if(meta != nullptr) {
             output_fasm_features(meta->as_string().get(strings_), "", "");
         }
 
-        walk_route_tree(rr_graph_builder, edge->child);
+        walk_route_tree(rr_graph_builder, child);
     }
 }
 
 void FasmWriterVisitor::walk_routing() {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
     const auto& device_ctx = g_vpr_ctx.device();
 
-    for(const auto &trace : route_ctx.trace) {
-      t_trace *head = trace.head;
-      if (!head) continue;
-      t_rt_node* root = traceback_to_route_tree(head, is_flat_);
-      walk_route_tree(device_ctx.rr_graph_builder, root);
-      free_route_tree(root);
+    for(const auto &root : route_ctx.rt_roots) {
+        if (!root) continue;
+        walk_route_tree(device_ctx.rr_graph_builder, root.value());
     }
 }
 

utils/fasm/src/fasm.cpp

@@ -73,7 +73,7 @@ class FasmWriterVisitor : public NetlistVisitor {
       void check_for_lut(const t_pb* atom);
       void output_fasm_mux(std::string fasm_mux, t_interconnect *interconnect, const t_pb_graph_pin *mux_input_pin);
       void walk_routing();
-      void walk_route_tree(const RRGraphBuilder& rr_graph_builder, const t_rt_node *root);
+      void walk_route_tree(const RRGraphBuilder& rr_graph_builder, const RouteTreeNode& root);
       std::string build_clb_prefix(const t_pb *pb, const t_pb_graph_node* pb_graph_node, bool* is_parent_pb_null) const;
       const LutOutputDefinition* find_lut(const t_pb_graph_node* pb_graph_node);
       void check_for_param(const t_pb *atom);

utils/fasm/src/fasm.h

@@ -1,6 +1,9 @@
 #include "catch2/catch_test_macros.hpp"
 #include "catch2/matchers/catch_matchers_all.hpp"
 
+#include "route_common.h"
+#include "route_tree_timing.h"
+#include "t_trace.h"
 #include "vpr_api.h"
 #include "vtr_util.h"
 #include "rr_metadata.h"
@@ -23,7 +26,6 @@ namespace {
 
 // ============================================================================
 
-using Catch::Matchers::Equals;
 using Catch::Matchers::StartsWith;
 using Catch::Matchers::ContainsSubstring;
 
@@ -586,21 +588,26 @@ TEST_CASE("fasm_integration_test", "[fasm]") {
 
     // Verify routes
     const auto & route_ctx = g_vpr_ctx.routing();
-    for(const auto &trace : route_ctx.trace) {
-        const t_trace *head = trace.head;
-        while(head != nullptr) {
-            const t_trace *next = head->next;
+    for(const auto& root : route_ctx.rt_roots) {
+        if(!root)
+            continue;
+
+        t_trace* head = traceback_from_route_tree_recurr(NULL, NULL, root.value()).first;
+        t_trace* tptr = head;
+        while(tptr != nullptr) {
+            t_trace* next = tptr->next;
 
-            if(next != nullptr && head->iswitch != OPEN) {
+            if(next != nullptr && tptr->iswitch != OPEN) {
                 const auto next_inode = next->index;
-                auto iter = routing_edges.find(std::make_tuple(head->index, next_inode, head->iswitch));
+                auto iter = routing_edges.find(std::make_tuple(tptr->index, next_inode, tptr->iswitch));
                 if (iter == routing_edges.end()) {
-                    FAIL_CHECK("source: " << head->index << " sink: " << next_inode << " switch:" << head->iswitch);
+                    FAIL_CHECK("source: " << tptr->index << " sink: " << next_inode << " switch:" << tptr->iswitch);
                 }
             }
 
-            head = next;
+            tptr = next;
         }
+        free_traceback(head);
     }
 
     // Verify CLB crossbar mux features against routed pin features.

utils/fasm/test/test_fasm.cpp

@@ -74,7 +74,7 @@ static void do_one_route(const Netlist<>& net_list,
     const auto& rr_graph = device_ctx.rr_graph;
     auto& route_ctx = g_vpr_ctx.routing();
 
-    t_rt_node* rt_root = init_route_tree_to_source_no_net(source_node);
+    RouteTreeRoot rt_root = init_route_tree_to_source_no_net(RRNodeId(source_node));
 
     /* Update base costs according to fanout and criticality rules */
     update_rr_base_costs(1);
@@ -128,19 +128,19 @@ static void do_one_route(const Netlist<>& net_list,
     if (found_path) {
         VTR_ASSERT(cheapest.index == sink_node);
 
-        t_rt_node* rt_node_of_sink = update_route_tree(&cheapest, OPEN, nullptr, router_opts.flat_routing);
+        vtr::optional<RouteTreeNode&> rt_node_of_sink;
+        std::tie(std::ignore, rt_node_of_sink) = update_route_tree(rt_root, &cheapest, OPEN, nullptr, router_opts.flat_routing);
 
         //find delay
-        float net_delay = rt_node_of_sink->Tdel;
+        float net_delay = rt_node_of_sink.value().Tdel;
         VTR_LOG("Routed successfully, delay = %g!\n", net_delay);
         VTR_LOG("\n");
         print_route_tree_node(rt_root);
         VTR_LOG("\n");
         print_route_tree(rt_root);
         VTR_LOG("\n");
 
-        VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= rr_graph.node_capacity(RRNodeId(rt_root->inode)), "SOURCE should never be congested");
-        free_route_tree(rt_root);
+        VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[size_t(rt_root.inode)].occ() <= rr_graph.node_capacity(RRNodeId(rt_root.inode)), "SOURCE should never be congested");
     } else {
         VTR_LOG("Routed failed");
     }

utils/route_diag/src/main.cpp

@@ -66,8 +66,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                                   std::shared_ptr<SetupHoldTimingInfo> timing_info,
                                   std::shared_ptr<RoutingDelayCalculator> delay_calc,
                                   bool is_flat) {
-    vtr::vector<ParentNetId, t_trace*> best_routing; /* Saves the best routing found so far. */
-
+    vtr::vector<ParentNetId, vtr::optional<RouteTreeRoot>> best_routing; /* Saves the best routing found so far. */
     int current, low, high, final;
     bool success, prev_success, prev2_success, Fc_clipped = false;
     bool using_minw_hint = false;
@@ -100,8 +99,6 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
         graph_directionality = (det_routing_arch->directionality == BI_DIRECTIONAL ? GRAPH_BIDIR : GRAPH_UNIDIR);
     }
 
-    best_routing = alloc_saved_routing(router_net_list);
-
     VTR_ASSERT(net_delay.size());
 
     if (det_routing_arch->directionality == BI_DIRECTIONAL)
@@ -416,7 +413,6 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                 filename_opts.RouteFile.c_str(),
                 is_flat);
 
-    free_saved_routing(router_net_list, best_routing);
     fflush(stdout);
 
     return (final);

vpr/src/base/place_and_route.cpp

@@ -402,7 +402,7 @@ static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* file
     }
 
     /* Convert to route_tree after reading */
-    route_ctx.current_rt[inet] = traceback_to_route_tree(head_ptr);
+    route_ctx.rt_roots[inet] = traceback_to_route_tree(head_ptr);
 }
 
 /**

vpr/src/base/read_route.cpp

@@ -247,7 +247,6 @@ static void load_channel_occupancies(const Netlist<>& net_list,
                                      vtr::Matrix<int>& chanx_occ,
                                      vtr::Matrix<int>& chany_occ) {
     int i, j, inode;
-    t_trace* tptr;
     t_rr_type rr_type;
 
     auto& device_ctx = g_vpr_ctx.device();
@@ -264,7 +263,12 @@ static void load_channel_occupancies(const Netlist<>& net_list,
         if (net_list.net_is_ignored(net_id) && net_list.net_sinks(net_id).size() != 0)
             continue;
 
-        tptr = traceback_from_route_tree_recurr(NULL, NULL, route_ctx.current_rt[net_id]).first;
+        auto& rt_node = route_ctx.rt_roots[net_id];
+        if(!rt_node)
+            continue;
+
+        t_trace* head = traceback_from_route_tree_recurr(NULL, NULL, rt_node.value()).first;
+        t_trace* tptr = head;
         while (tptr != nullptr) {
             inode = tptr->index;
             rr_type = rr_graph.node_type(RRNodeId(inode));
@@ -289,6 +293,8 @@ static void load_channel_occupancies(const Netlist<>& net_list,
 
             tptr = tptr->next;
         }
+
+        free_traceback(head);
     }
 }
 
@@ -301,7 +307,7 @@ void get_num_bends_and_length(ParentNetId inet, int* bends_ptr, int* len_ptr, in
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
-    t_trace *tptr, *prevptr;
+    t_trace *tptr, *head;
     int inode;
     t_rr_type curr_type, prev_type;
     int bends, length, segments;
@@ -312,15 +318,17 @@ void get_num_bends_and_length(ParentNetId inet, int* bends_ptr, int* len_ptr, in
     length = 0;
     segments = 0;
 
-    prevptr = traceback_from_route_tree_recurr(NULL, NULL, route_ctx.current_rt[inet]).first; /* Should always be SOURCE. */
-    if (prevptr == nullptr) {
+	auto net_root = route_ctx.rt_roots[inet];
+	if(!net_root){
         VPR_FATAL_ERROR(VPR_ERROR_OTHER,
                         "in get_num_bends_and_length: net #%lu has no traceback.\n", size_t(inet));
-    }
-    inode = prevptr->index;
+	}
+
+    head = traceback_from_route_tree_recurr(NULL, NULL, net_root.value()).first; /* Should always be SOURCE. */
+    inode = head->index;
     prev_type = rr_graph.node_type(RRNodeId(inode));
 
-    tptr = prevptr->next;
+    tptr = head->next;
 
     while (tptr != nullptr) {
         inode = tptr->index;
@@ -347,6 +355,8 @@ void get_num_bends_and_length(ParentNetId inet, int* bends_ptr, int* len_ptr, in
         tptr = tptr->next;
     }
 
+    free_traceback(head);
+
     *bends_ptr = bends;
     *len_ptr = length;
     *segments_ptr = segments;

vpr/src/base/stats.cpp

@@ -1183,7 +1183,7 @@ static void free_placement() {
 
 static void free_routing() {
     auto& routing_ctx = g_vpr_ctx.mutable_routing();
-    routing_ctx.current_rt.clear();
+    routing_ctx.rt_roots.clear();
     routing_ctx.trace_nodes.clear();
     routing_ctx.net_rr_terminals.clear();
     routing_ctx.rr_blk_source.clear();
@@ -1375,7 +1375,7 @@ void vpr_analysis(const Netlist<>& net_list,
 
     //Check the first index to see if a pointer exists
     //TODO: Implement a better error check
-    if (route_ctx.current_rt.empty()) {
+    if (route_ctx.rt_roots.empty()) {
         VPR_FATAL_ERROR(VPR_ERROR_ANALYSIS, "No routing loaded -- can not perform post-routing analysis");
     }
 

vpr/src/base/vpr_api.cpp

@@ -7,6 +7,7 @@
 
 #include "vpr_types.h"
 #include "vtr_ndmatrix.h"
+#include "vtr_optional.h"
 #include "vtr_vector.h"
 #include "atom_netlist.h"
 #include "clustered_netlist.h"
@@ -393,7 +394,7 @@ struct PlacementContext : public Context {
  */
 struct RoutingContext : public Context {
     /* [0..num_nets-1] of linked list start pointers.  Defines the routing.  */
-    vtr::vector<ParentNetId, t_rt_node*> current_rt;
+    vtr::vector<ParentNetId, vtr::optional<RouteTreeRoot>> rt_roots;
 
     vtr::vector<ParentNetId, std::unordered_set<int>> trace_nodes;
 

vpr/src/base/vpr_context.h

@@ -847,54 +847,43 @@ std::vector<int> trace_routed_connection_rr_nodes(
     bool is_flat) {
     auto& route_ctx = g_vpr_ctx.routing();
 
-    bool allocated_route_tree_structs = alloc_route_tree_timing_structs(true); //Needed for traceback_to_route_tree
+    VTR_ASSERT(route_ctx.rt_roots[net_id]);
+    const RouteTreeNode& net_root = route_ctx.rt_roots[net_id].value();
 
-    t_rt_node* rt_root = route_ctx.current_rt[net_id];
-
-    VTR_ASSERT(
-        rt_root
-        && rt_root->inode
-               == route_ctx.net_rr_terminals[ParentNetId(size_t(net_id))][driver_pin]);
+    VTR_ASSERT(net_root.inode == RRNodeId(route_ctx.net_rr_terminals[net_id][driver_pin]));
 
     int sink_rr_node = route_ctx.net_rr_terminals[ParentNetId(size_t(net_id))][sink_pin];
 
     std::vector<int> rr_nodes_on_path;
 
     //Collect the rr nodes
-    trace_routed_connection_rr_nodes_recurr(rt_root, sink_rr_node,
+    trace_routed_connection_rr_nodes_recurr(net_root, sink_rr_node,
                                             rr_nodes_on_path);
 
     //Traced from sink to source, but we want to draw from source to sink
     std::reverse(rr_nodes_on_path.begin(), rr_nodes_on_path.end());
 
-    if (allocated_route_tree_structs) {
-        free_route_tree_timing_structs();
-    }
     return rr_nodes_on_path;
 }
 
 //Helper function for trace_routed_connection_rr_nodes
 //Adds the rr nodes linking rt_node to sink_rr_node to rr_nodes_on_path
 //Returns true if rt_node is on the path
-bool trace_routed_connection_rr_nodes_recurr(const t_rt_node* rt_node,
+bool trace_routed_connection_rr_nodes_recurr(const RouteTreeNode& rt_node,
                                              int sink_rr_node,
                                              std::vector<int>& rr_nodes_on_path) {
     //DFS from the current rt_node to the sink_rr_node, when the sink is found trace back the used rr nodes
 
-    if (rt_node->inode == sink_rr_node) {
+    if (rt_node.inode == RRNodeId(sink_rr_node)) {
         rr_nodes_on_path.push_back(sink_rr_node);
         return true;
     }
 
-    for (t_linked_rt_edge* edge = rt_node->u.child_list; edge != nullptr; edge = edge->next) {
-        t_rt_node* child_rt_node = edge->child;
-        VTR_ASSERT(child_rt_node);
-
+    for(const RouteTreeNode& child_rt_node: rt_node.child_nodes()){
         bool on_path_to_sink = trace_routed_connection_rr_nodes_recurr(
             child_rt_node, sink_rr_node, rr_nodes_on_path);
-
         if (on_path_to_sink) {
-            rr_nodes_on_path.push_back(rt_node->inode);
+            rr_nodes_on_path.push_back(size_t(rt_node.inode));
             return true;
         }
     }