Merge pull request #3203 from AlexPoupakis/deterministic_parallel_router

AlexandreSinger · web-flow · commit 246053dfea69 · 2025-08-20T19:46:34.000-04:00
Deterministic parallel router
diff --git a/doc/src/vpr/command_line_usage.rst b/doc/src/vpr/command_line_usage.rst
@@ -1887,6 +1887,9 @@ The following options are only valid when the router is in timing-driven mode (t
 
      * ``classic``: The classic VPR lookahead
      * ``map``: A more advanced lookahead which accounts for diverse wire types and their connectivity
+     * ``compressed_map``: The algorithm is similar to map lookahead with the exception of sparse sampling of the chip to reduce the run-time to build the router lookahead and also its memory footprint.
+     * ``extended_map``: A more advanced and extended lookahead which accounts for a more exhaustive node sampling method.
+     * ``simple``: A purely distance-based lookahead loaded from an external file using :option:`--read_router_lookahead`. This lookahead returns a cost estimate for channel nodes by querying a lookup table, while for any other node type it returns zero.
 
      **Default:** ``map``
 
diff --git a/vpr/src/base/ShowSetup.cpp b/vpr/src/base/ShowSetup.cpp
@@ -435,6 +435,9 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
             case e_router_lookahead::EXTENDED_MAP:
                 VTR_LOG("EXTENDED_MAP\n");
                 break;
+            case e_router_lookahead::SIMPLE:
+                VTR_LOG("SIMPLE\n");
+                break;
             case e_router_lookahead::NO_OP:
                 VTR_LOG("NO_OP\n");
                 break;
diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp
@@ -1070,6 +1070,8 @@ struct ParseRouterLookahead {
             conv_value.set_value(e_router_lookahead::COMPRESSED_MAP);
         else if (str == "extended_map")
             conv_value.set_value(e_router_lookahead::EXTENDED_MAP);
+        else if (str == "simple")
+            conv_value.set_value(e_router_lookahead::SIMPLE);
         else {
             std::stringstream msg;
             msg << "Invalid conversion from '"
@@ -1089,6 +1091,8 @@ struct ParseRouterLookahead {
             conv_value.set_value("map");
         } else if (val == e_router_lookahead::COMPRESSED_MAP) {
             conv_value.set_value("compressed_map");
+        } else if (val == e_router_lookahead::SIMPLE) {
+            conv_value.set_value("simple");
         } else {
             VTR_ASSERT(val == e_router_lookahead::EXTENDED_MAP);
             conv_value.set_value("extended_map");
@@ -1097,7 +1101,7 @@ struct ParseRouterLookahead {
     }
 
     std::vector<std::string> default_choices() {
-        return {"classic", "map", "compressed_map", "extended_map"};
+        return {"classic", "map", "compressed_map", "extended_map", "simple"};
     }
 };
 
@@ -2970,6 +2974,7 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
             " to reduce the run-time to build the router lookahead and also its memory footprint\n"
             " * extended_map: A more advanced and extended lookahead which accounts for a more\n"
             "                 exhaustive node sampling method\n"
+            " * simple: A purely distance-based lookahead loaded from an external file\n"
             "\n"
             " The extended map differs from the map lookahead in the lookahead computation.\n"
             " It is better suited for architectures that have specialized routing for specific\n"
diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h
@@ -107,6 +107,8 @@ enum class e_router_lookahead {
     COMPRESSED_MAP,
     ///@brief Lookahead with a more extensive node sampling method
     EXTENDED_MAP,
+    ///@brief Simple distance-based lookahead
+    SIMPLE,
     ///@brief A no-operation lookahead which always returns zero
     NO_OP
 };
diff --git a/vpr/src/route/parallel_connection_router.cpp b/vpr/src/route/parallel_connection_router.cpp
@@ -33,7 +33,9 @@ static inline bool post_target_prune_node(float new_total_cost,
     // Max function to prevent the heuristic from going negative
     new_expected_cost = std::max(0.f, new_expected_cost);
     new_expected_cost *= params.post_target_prune_fac;
-    if ((new_back_cost + new_expected_cost) > best_back_cost_to_target)
+
+    // NOTE: in the check below, the multiplication factor is used to account for floating point errors.
+    if ((new_back_cost + new_expected_cost) * 0.999f > best_back_cost_to_target)
         return true;
     // NOTE: we do NOT check for equality here. Equality does not matter for
     //       determinism when draining the queues (may just lead to a bit more work).
diff --git a/vpr/src/route/router_lookahead/router_lookahead.cpp b/vpr/src/route/router_lookahead/router_lookahead.cpp
@@ -4,6 +4,7 @@
 #include "router_lookahead_map.h"
 #include "router_lookahead_compressed_map.h"
 #include "router_lookahead_extended_map.h"
+#include "router_lookahead_simple.h"
 #include "vpr_error.h"
 #include "globals.h"
 
@@ -30,6 +31,8 @@ static std::unique_ptr<RouterLookahead> make_router_lookahead_object(const t_det
         return std::make_unique<CompressedMapLookahead>(det_routing_arch, is_flat);
     } else if (router_lookahead_type == e_router_lookahead::EXTENDED_MAP) {
         return std::make_unique<ExtendedMapLookahead>(is_flat);
+    } else if (router_lookahead_type == e_router_lookahead::SIMPLE) {
+        return std::make_unique<SimpleLookahead>();
     } else if (router_lookahead_type == e_router_lookahead::NO_OP) {
         return std::make_unique<NoOpLookahead>();
     }
diff --git a/vpr/src/route/router_lookahead/router_lookahead_simple.cpp b/vpr/src/route/router_lookahead/router_lookahead_simple.cpp
@@ -0,0 +1,185 @@
+/*
+ * The router lookahead provides an estimate of the cost from an intermediate node to the target node
+ * during directed (A*-like) routing.
+ *
+ * The lookahead in this file requires an externally loaded lookahead cost map which will be queried 
+ * based only on the distance between the currently explored node and the target sink.
+ * 
+ * This lookahead can be made admissible if the loaded cost map contains the minimum delay and minimum
+ * congestion costs per distance.
+ */
+
+#include <algorithm>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+#include <queue>
+#include <fstream>
+#include "globals.h"
+#include "vtr_time.h"
+#include "router_lookahead.h"
+#include "router_lookahead_simple.h"
+#include "router_lookahead_map_utils.h"
+#include "rr_graph.h"
+#include "connection_router_interface.h"
+#include "arch_util.h"
+
+#ifdef VTR_ENABLE_CAPNPROTO
+#include "capnp/serialize.h"
+#include "map_lookahead.capnp.h"
+#include "ndmatrix_serdes.h"
+#include "intra_cluster_serdes.h"
+#include "mmap_file.h"
+#include "serdes_utils.h"
+#endif /* VTR_ENABLE_CAPNPROTO */
+
+/******** File-Scope Variables ********/
+
+//Look-up table from CHANX/CHANY (to SINKs) for various distances
+static t_simple_cost_map simple_cost_map;
+
+/******** File-Scope Functions ********/
+
+static util::Cost_Entry get_wire_cost_entry(e_rr_type rr_type,
+                                            int seg_index,
+                                            int from_layer_num,
+                                            int delta_x,
+                                            int delta_y,
+                                            int to_layer_num);
+
+static void read_router_lookahead(const std::string& file);
+static void write_router_lookahead(const std::string& file);
+
+/******** Interface class member function definitions ********/
+
+float SimpleLookahead::get_expected_cost(RRNodeId current_node, RRNodeId target_node, const t_conn_cost_params& params, float R_upstream) const {
+    // Get the total cost using the combined delay and congestion costs
+    auto [delay_cost, cong_cost] = get_expected_delay_and_cong(current_node, target_node, params, R_upstream);
+    return delay_cost + cong_cost;
+}
+
+std::pair<float, float> SimpleLookahead::get_expected_delay_and_cong(RRNodeId from_node, RRNodeId to_node, const t_conn_cost_params& params, float /*R_upstream*/) const {
+    auto& device_ctx = g_vpr_ctx.device();
+    auto& rr_graph = device_ctx.rr_graph;
+
+    float expected_delay_cost = std::numeric_limits<float>::max() / 1e12;
+    float expected_cong_cost = std::numeric_limits<float>::max() / 1e12;
+
+    e_rr_type from_type = rr_graph.node_type(from_node);
+    util::Cost_Entry cost_entry(0, 0);
+    if (is_chanxy(from_type) || is_chanz(from_type)) {
+        int from_layer_num = rr_graph.node_layer(from_node);
+        int to_layer_num = rr_graph.node_layer(to_node);
+
+        auto [delta_x, delta_y] = util::get_xy_deltas(from_node, to_node);
+        delta_x = abs(delta_x);
+        delta_y = abs(delta_y);
+
+        auto from_cost_index = rr_graph.node_cost_index(from_node);
+        int from_seg_index = device_ctx.rr_indexed_data[from_cost_index].seg_index;
+
+        cost_entry = get_wire_cost_entry(from_type, from_seg_index, from_layer_num, delta_x, delta_y, to_layer_num);
+    }
+
+    if (cost_entry.valid()) {
+        float expected_delay = cost_entry.delay;
+        float expected_cong = cost_entry.congestion;
+
+        expected_delay_cost = params.criticality * expected_delay;
+        expected_cong_cost = (1.0 - params.criticality) * expected_cong;
+    }
+
+    return std::make_pair(expected_delay_cost, expected_cong_cost);
+}
+
+void SimpleLookahead::read(const std::string& file) {
+    read_router_lookahead(file);
+}
+
+void SimpleLookahead::write(const std::string& file) const {
+    if (vtr::check_file_name_extension(file, ".csv")) {
+        std::vector<int> simple_cost_map_size(simple_cost_map.ndims());
+        for (size_t i = 0; i < simple_cost_map.ndims(); ++i) {
+            simple_cost_map_size[i] = static_cast<int>(simple_cost_map.dim_size(i));
+        }
+        dump_readable_router_lookahead_map(file, simple_cost_map_size, get_wire_cost_entry);
+    } else {
+        VTR_ASSERT(vtr::check_file_name_extension(file, ".capnp") || vtr::check_file_name_extension(file, ".bin"));
+        write_router_lookahead(file);
+    }
+}
+
+/******** Function Definitions ********/
+
+static util::Cost_Entry get_wire_cost_entry(e_rr_type rr_type, int seg_index, int from_layer_num, int delta_x, int delta_y, int to_layer_num) {
+    VTR_ASSERT_SAFE(rr_type == e_rr_type::CHANX || rr_type == e_rr_type::CHANY);
+    VTR_ASSERT_SAFE(from_layer_num < static_cast<int>(simple_cost_map.dim_size(0)));
+    VTR_ASSERT_SAFE(to_layer_num < static_cast<int>(simple_cost_map.dim_size(1)));
+    VTR_ASSERT_SAFE(seg_index < static_cast<int>(simple_cost_map.dim_size(3)));
+    VTR_ASSERT_SAFE(delta_x < static_cast<int>(simple_cost_map.dim_size(4)));
+    VTR_ASSERT_SAFE(delta_y < static_cast<int>(simple_cost_map.dim_size(5)));
+
+    int chan_index = 0;
+    if (rr_type == e_rr_type::CHANY) {
+        chan_index = 1;
+    }
+
+    return simple_cost_map[from_layer_num][to_layer_num][chan_index][seg_index][delta_x][delta_y];
+}
+
+//
+// When writing capnp targetted serialization, always allow compilation when
+// VTR_ENABLE_CAPNPROTO=OFF.  Generally this means throwing an exception
+// instead.
+//
+#ifndef VTR_ENABLE_CAPNPROTO
+
+#define DISABLE_ERROR                               \
+    "is disabled because VTR_ENABLE_CAPNPROTO=OFF." \
+    "Re-compile with CMake option VTR_ENABLE_CAPNPROTO=ON to enable."
+
+void read_router_lookahead(const std::string& /*file*/) {
+    VPR_THROW(VPR_ERROR_PLACE, "SimpleLookahead::read_router_lookahead " DISABLE_ERROR);
+}
+
+void write_router_lookahead(const std::string& /*file*/) {
+    VPR_THROW(VPR_ERROR_PLACE, "SimpleLookahead::write_router_lookahead " DISABLE_ERROR);
+}
+
+#else /* VTR_ENABLE_CAPNPROTO */
+
+static void ToCostEntry(util::Cost_Entry* out, const VprMapCostEntry::Reader& in) {
+    out->delay = in.getDelay();
+    out->congestion = in.getCongestion();
+}
+
+static void FromCostEntry(VprMapCostEntry::Builder* out, const util::Cost_Entry& in) {
+    out->setDelay(in.delay);
+    out->setCongestion(in.congestion);
+}
+
+void read_router_lookahead(const std::string& file) {
+    vtr::ScopedStartFinishTimer timer("Loading router wire lookahead map");
+    MmapFile f(file);
+
+    /* Increase reader limit to 1G words to allow for large files. */
+    ::capnp::ReaderOptions opts = default_large_capnp_opts();
+    ::capnp::FlatArrayMessageReader reader(f.getData(), opts);
+
+    auto map = reader.getRoot<VprMapLookahead>();
+
+    ToNdMatrix<6, VprMapCostEntry, util::Cost_Entry>(&simple_cost_map, map.getCostMap(), ToCostEntry);
+}
+
+void write_router_lookahead(const std::string& file) {
+    ::capnp::MallocMessageBuilder builder;
+
+    auto map = builder.initRoot<VprMapLookahead>();
+
+    auto cost_map = map.initCostMap();
+    FromNdMatrix<6, VprMapCostEntry, util::Cost_Entry>(&cost_map, simple_cost_map, FromCostEntry);
+
+    writeMessageToFile(file, &builder);
+}
+
+#endif
diff --git a/vpr/src/route/router_lookahead/router_lookahead_simple.h b/vpr/src/route/router_lookahead/router_lookahead_simple.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include "vtr_ndmatrix.h"
+#include "router_lookahead.h"
+#include "router_lookahead_map_utils.h"
+
+/**
+ * @brief A lookahead that can only read a cost map from a file and query it based on distance.
+ *
+ * SimpleLookahead cannot compute a cost map, instead it can only read a single cost map from an external file.
+ * This cost map is similar to that of MapLookahead, and it only refers to channel segments. There is no additional
+ * cost map for sources/opins or intra-cluster estimates.
+ */
+class SimpleLookahead : public RouterLookahead {
+  protected:
+    float get_expected_cost(RRNodeId node, RRNodeId target_node, const t_conn_cost_params& params, float R_upstream) const override;
+    std::pair<float, float> get_expected_delay_and_cong(RRNodeId from_node, RRNodeId to_node, const t_conn_cost_params& params, float R_upstream) const override;
+
+    void compute(const std::vector<t_segment_inf>& /*segment_inf*/) override {
+        VPR_THROW(VPR_ERROR_ROUTE, "SimpleLookahead::compute unsupported, try to load lookahead from a file.");
+    }
+
+    void compute_intra_tile() override {
+        VPR_THROW(VPR_ERROR_ROUTE, "SimpleLookahead::compute_intra_tile unimplemented");
+    }
+
+    void read(const std::string& file) override;
+
+    void read_intra_cluster(const std::string& /*file*/) override {
+        VPR_THROW(VPR_ERROR_ROUTE, "SimpleLookahead::read_intra_cluster unimplemented");
+    }
+
+    void write(const std::string& file) const override;
+
+    void write_intra_cluster(const std::string& /*file*/) const override {
+        VPR_THROW(VPR_ERROR_ROUTE, "SimpleLookahead::write_intra_cluster unimplemented");
+    }
+
+    float get_opin_distance_min_delay(int /*physical_tile_idx*/, int /*from_layer*/, int /*to_layer*/, int /*dx*/, int /*dy*/) const override {
+        return -1;
+    }
+};
+
+/* provides delay/congestion estimates to travel specified distances
+ * in the x/y direction */
+// This is a 6D array storing the cost to travel from a node of type CHANX/CHANY to a point that is dx, dy further, and is on the "layer_num" layer.
+// To store this information, the first index is the layer number that the node under consideration is on, the second index is the layer number of the target node, the third index represents the type of channel (X/Y)
+// that the node under consideration belongs to, the forth is the segment type (specified in the architecture file under the "segmentlist" tag), the fourth is the
+// target "layer_num" mentioned above, the fifth is dx, and the last one is dy.
+typedef vtr::NdMatrix<util::Cost_Entry, 6> t_simple_cost_map; //[0..num_layers][0..num_layers][0..1][[0..num_seg_types-1][0..device_ctx.grid.width()-1][0..device_ctx.grid.height()-1]
+                                                              //[0..1] entry distinguish between CHANX/CHANY start nodes respectively
+                                                              // The first index is the layer number that the node under consideration is on, and the second index
+                                                              // is the layer number that the target node is on.
