remove traceback, replace rt_node with RouteTree

Author: duck2

libs/libvtrutil/src/tl_optional.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+/** std::optional-like interface with optional references.
+ * currently: import TartanLlama's optional into the vtr namespace
+ * documentation at https://tl.tartanllama.xyz/en/latest/api/optional.html
+ * there are three main uses of this:
+ * 1. replace pointers when refactoring legacy code
+ *   optional<T&> (reference) is in many ways a pointer, it even has * and -> operators,
+ *   but it can't be allocated or freed. this property is very helpful in refactoring.
+ * 2. explicit alternative for containers
+ *   optional<T> (non-reference) allows you to put non-empty-initializable
+ *   objects into a container which owns them. it is an alternative to
+ *   unique_ptr<T> in that sense, but with a cleaner interface.
+ * 3. function return types
+ *   returning an optional<T> gives the caller a clear hint to check the return value.
+ *
+ * Q: why not use std::optional?
+ * A: std::optional doesn't allow optional<T&> due to a disagreement about
+ * what it means to assign to an optional reference. tl::optional permits this, with
+ * "rebind on assignment" behavior. this means opt<T&> acts very similarly to a pointer.
+ * Q: why do we need opt<T&>? there's already T*.
+ * A: in an ideal world where all pointers are aliases to existing values and nothing
+ * else, opt<T&> wouldn't be that necessary. however VPR is full of legacy code where
+ * the usual C++ conventions about pointers don't apply.
+ * when refactoring such code, turning all pointers into opt<T&> helps a lot.
+ * it can't be allocated or freed and doesn't allow pointer arithmetic.
+ * in that aspect it acts as a "enforced proper C++ ptr".
+ * that's why I think it's worth keeping around in the codebase. */
+
+#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;
+} // namespace vtr

libs/libvtrutil/src/vtr_optional.h

@@ -22,7 +22,6 @@
 #include "atom_netlist_utils.h"
 #include "netlist_writer.h"
 #include "vpr_utils.h"
-#include "route_tree_timing.h"
 
 #include "fasm_utils.h"
 
@@ -619,31 +618,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 &tree : route_ctx.route_trees) {
+        if (!tree) continue;
+        walk_route_tree(device_ctx.rr_graph_builder, tree.value().root());
     }
 }
 

utils/fasm/src/fasm.cpp

@@ -22,7 +22,7 @@
 #include "netlist_writer.h"
 #include "lut.h"
 #include "parameters.h"
-#include "route_tree_type.h"
+#include "route_tree_fwd.h"
 
 namespace fasm {
 
@@ -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

@@ -120,11 +120,7 @@ int main(int argc, const char **argv) {
                 (float) (entire_flow_end - entire_flow_begin) / CLOCKS_PER_SEC);
 
         /* free data structures */
-        if(is_flat) {
-            vpr_free_all((const Netlist<>&) g_vpr_ctx.atom().nlist, Arch, vpr_setup);
-        } else {
-            vpr_free_all((const Netlist<>&) g_vpr_ctx.clustering().clb_nlist, Arch, vpr_setup);
-        }
+        vpr_free_all(Arch, vpr_setup);
 
 
     } catch (const tatum::Error& tatum_error) {

utils/fasm/src/main.cpp

@@ -1,6 +1,7 @@
 #include "catch2/catch_test_macros.hpp"
 #include "catch2/matchers/catch_matchers_all.hpp"
 
+#include "route_common.h"
 #include "vpr_api.h"
 #include "vtr_util.h"
 #include "rr_metadata.h"
@@ -23,7 +24,6 @@ namespace {
 
 // ============================================================================
 
-using Catch::Matchers::Equals;
 using Catch::Matchers::StartsWith;
 using Catch::Matchers::ContainsSubstring;
 
@@ -296,7 +296,7 @@ TEST_CASE("fasm_integration_test", "[fasm]") {
                        echo_enabled,
                        echo_file_name,
                        is_flat);
-        vpr_free_all((const Netlist<>&) g_vpr_ctx.clustering().clb_nlist, arch, vpr_setup);
+        vpr_free_all(arch, vpr_setup);
     }
 
     t_vpr_setup vpr_setup;
@@ -586,20 +586,17 @@ 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;
-
-            if(next != nullptr && head->iswitch != OPEN) {
-                const auto next_inode = next->index;
-                auto iter = routing_edges.find(std::make_tuple(head->index, next_inode, head->iswitch));
+    for(const auto& root : route_ctx.route_trees) {
+        if(!root)
+            continue;
+
+        for(auto& rt_node: root.value().all_nodes()) {
+            for(auto& child_node: rt_node.child_nodes()){
+                auto iter = routing_edges.find(std::make_tuple(size_t(rt_node.inode), size_t(child_node.inode), size_t(child_node.parent_switch)));
                 if (iter == routing_edges.end()) {
-                    FAIL_CHECK("source: " << head->index << " sink: " << next_inode << " switch:" << head->iswitch);
+                    FAIL_CHECK("source: " << size_t(rt_node.inode) << " sink: " << size_t(child_node.inode) << " switch:" << size_t(child_node.parent_switch));
                 }
             }
-
-            head = next;
         }
     }
 
@@ -635,7 +632,7 @@ TEST_CASE("fasm_integration_test", "[fasm]") {
     CHECK(found_mux4);
 
 
-    vpr_free_all((const Netlist<>&) g_vpr_ctx.clustering().clb_nlist, arch, vpr_setup);
+    vpr_free_all(arch, vpr_setup);
 }
 
 } // namespace

utils/fasm/test/test_fasm.cpp

@@ -12,7 +12,7 @@ TEST_CASE("default_lut", "[fasm]") {
         fasm::Lut lut(num_inputs);
 
         const LogicVec &table = lut.table();
-        CHECK(table.size() == (1 << num_inputs));
+        CHECK(table.size() == size_t(1 << num_inputs));
 
         for(const vtr::LogicValue & value : table) {
             CHECK(value == vtr::LogicValue::FALSE);
@@ -27,7 +27,7 @@ TEST_CASE("const_true", "[fasm]") {
         lut.SetConstant(vtr::LogicValue::TRUE);
 
         const LogicVec &table = lut.table();
-        CHECK(table.size() == (1 << num_inputs));
+        CHECK(table.size() == size_t(1 << num_inputs));
 
         for(const vtr::LogicValue & value : table) {
             CHECK(value == vtr::LogicValue::TRUE);
@@ -42,7 +42,7 @@ TEST_CASE("const_false", "[fasm]") {
             lut.SetConstant(vtr::LogicValue::FALSE);
 
             const LogicVec &table = lut.table();
-            CHECK(table.size() == (1 << num_inputs));
+            CHECK(table.size() == size_t(1 << num_inputs));
 
             for(const vtr::LogicValue & value : table) {
                 CHECK(value == vtr::LogicValue::FALSE);
@@ -58,7 +58,7 @@ TEST_CASE("wire", "[fasm]") {
             lut.CreateWire(input_pin);
 
             const LogicVec &table = lut.table();
-            CHECK(table.size() == (1 << num_inputs));
+            CHECK(table.size() == size_t(1 << num_inputs));
             for(size_t i = 0; i < table.size(); ++i) {
                 if(((1 << input_pin) & i) != 0) {
                     CHECK(table[i] == vtr::LogicValue::TRUE);

utils/fasm/test/test_lut.cpp

@@ -31,10 +31,9 @@
 #include "RoutingDelayCalculator.h"
 #include "place_and_route.h"
 #include "router_delay_profiling.h"
-#include "route_tree_type.h"
+#include "route_tree.h"
 #include "route_common.h"
 #include "route_timing.h"
-#include "route_tree_timing.h"
 #include "route_export.h"
 #include "rr_graph.h"
 #include "rr_graph2.h"
@@ -74,7 +73,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);
+    RouteTree tree((RRNodeId(source_node)));
 
     /* Update base costs according to fanout and criticality rules */
     update_rr_base_costs(1);
@@ -118,31 +117,29 @@ static void do_one_route(const Netlist<>& net_list,
                                      -1,
                                      false,
                                      std::unordered_map<RRNodeId, int>());
-    std::tie(found_path, cheapest) = router.timing_driven_route_connection_from_route_tree(rt_root,
-                                                                                           sink_node,
-                                                                                           cost_params,
-                                                                                           bounding_box,
-                                                                                           router_stats,
-                                                                                           conn_params);
+    std::tie(found_path, cheapest) = router.timing_driven_route_connection_from_route_tree(tree.root(),
+                                                                                                    sink_node,
+                                                                                                    cost_params,
+                                                                                                    bounding_box,
+                                                                                                    router_stats,
+                                                                                                    conn_params);
 
     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) = tree.update_from_heap(&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);
+        tree.print();
         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(tree.root().inode)].occ() <= rr_graph.node_capacity(tree.root().inode), "SOURCE should never be congested");
     } else {
-        VTR_LOG("Routed failed");
+        VTR_LOG("Routing failed");
     }
 
     //Reset for the next router call
@@ -347,10 +344,10 @@ int main(int argc, const char **argv) {
                          vpr_setup.Segments,
                          is_flat);
         }
-        free_routing_structs(net_list);
+        free_routing_structs();
 
         /* free data structures */
-        vpr_free_all(net_list, Arch, vpr_setup);
+        vpr_free_all(Arch, vpr_setup);
 
     } catch (const tatum::Error& tatum_error) {
         vtr::printf_error(__FILE__, __LINE__, "STA Engine: %s\n", tatum_error.what());