Merge branch 'noc_turn_model_routing' into noc_pack_part

Author: soheilshahrouz

libs/libvtrutil/src/vtr_util.cpp

@@ -125,7 +125,7 @@ std::string string_fmt(const char* fmt, ...) {
 
 ///@brief Returns a std::string formatted using a printf-style format string taking an explicit va_list
 std::string vstring_fmt(const char* fmt, va_list args) {
-    // We need to copy the args so we don't change them before the true formating
+    // We need to copy the args so we don't change them before the true formatting
     va_list va_args_copy;
     va_copy(va_args_copy, args);
 

vpr/src/base/SetupVPR.cpp

@@ -735,6 +735,7 @@ static void SetupNocOpts(const t_options& Options, t_noc_opts* NocOpts) {
     NocOpts->noc_flows_file = Options.noc_flows_file;
     NocOpts->noc_routing_algorithm = Options.noc_routing_algorithm;
     NocOpts->noc_placement_weighting = Options.noc_placement_weighting;
+    NocOpts->noc_aggregate_bandwidth_weighting = Options.noc_agg_bandwidth_weighting;
     NocOpts->noc_latency_constraints_weighting = Options.noc_latency_constraints_weighting;
     NocOpts->noc_latency_weighting = Options.noc_latency_weighting;
     NocOpts->noc_congestion_weighting = Options.noc_congestion_weighting;

vpr/src/base/ShowSetup.cpp

@@ -608,7 +608,7 @@ static void ShowPlacerOpts(const t_placer_opts& PlacerOpts,
         }
 
         VTR_LOG("PlacerOpts.constraints_file: ");
-        if (PlacerOpts.constraints_file == "") {
+        if (PlacerOpts.constraints_file.empty()) {
             VTR_LOG("No constraints file given\n");
         } else {
             VTR_LOG("Using constraints file '%s'\n", PlacerOpts.constraints_file.c_str());
@@ -795,6 +795,7 @@ static void ShowNocOpts(const t_noc_opts& NocOpts) {
     VTR_LOG("NocOpts.noc_flows_file: %s\n", NocOpts.noc_flows_file.c_str());
     VTR_LOG("NocOpts.noc_routing_algorithm: %s\n", NocOpts.noc_routing_algorithm.c_str());
     VTR_LOG("NocOpts.noc_placement_weighting: %f\n", NocOpts.noc_placement_weighting);
+    VTR_LOG("NocOpts.noc_aggregate_bandwidth_weighting: %f\n", NocOpts.noc_aggregate_bandwidth_weighting);
     VTR_LOG("NocOpts.noc_latency_constraints_weighting: %f\n", NocOpts.noc_latency_constraints_weighting);
     VTR_LOG("NocOpts.noc_latency_weighting: %f\n", NocOpts.noc_latency_weighting);
     VTR_LOG("NocOpts.noc_congestion_weighting: %f\n", NocOpts.noc_congestion_weighting);

vpr/src/base/read_options.cpp

@@ -2810,7 +2810,8 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
             "* bfs_routing: Uses the breadth first search algorithm. The objective is to find a route that uses a minimum number of links.\n"
             "This can be used with any NoC topology\n")
         .default_value("bfs_routing")
-        .choices({"xy_routing", "bfs_routing"})
+        .choices({"xy_routing", "bfs_routing", "west_first_routing", "north_last_routing", "negative_first_routing",
+                  "odd_even_routing"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     noc_grp.add_argument<double>(args.noc_placement_weighting, "--noc_placement_weighting")
@@ -2822,6 +2823,16 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("5.0")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    noc_grp.add_argument<double>(args.noc_agg_bandwidth_weighting, "--noc_aggregate_bandwidth_weighting")
+        .help(
+            "Controls the importance of minimizing the NoC aggregate bandwidth.\n"
+            "This value can be >=0, where 0 would mean the aggregate bandwidth has no relevance to placement.\n"
+            "Other positive numbers specify the importance of minimizing the NoC aggregate bandwidth to other NoC-related cost terms.\n"
+            "Weighting factors for NoC-related cost terms are normalized internally. Therefore, their absolute values are not important, and"
+            "only their relative ratios determine the importance of each cost term.")
+        .default_value("0.38")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     noc_grp.add_argument<double>(args.noc_latency_constraints_weighting, "--noc_latency_constraints_weighting")
         .help(
             "Controls the importance of meeting all the NoC traffic flow latency constraints.\n"

vpr/src/base/read_options.h

@@ -153,6 +153,7 @@ struct t_options {
     argparse::ArgValue<std::string> noc_flows_file;
     argparse::ArgValue<std::string> noc_routing_algorithm;
     argparse::ArgValue<double> noc_placement_weighting;
+    argparse::ArgValue<double> noc_agg_bandwidth_weighting;
     argparse::ArgValue<double> noc_latency_constraints_weighting;
     argparse::ArgValue<double> noc_latency_weighting;
     argparse::ArgValue<double> noc_congestion_weighting;

vpr/src/noc/bfs_routing.cpp

@@ -1,10 +1,15 @@
-#
+
+#include <queue>
 
 #include "bfs_routing.h"
 
-BFSRouting::~BFSRouting() {}
+BFSRouting::~BFSRouting() = default;
 
-void BFSRouting::route_flow(NocRouterId src_router_id, NocRouterId sink_router_id, std::vector<NocLinkId>& flow_route, const NocStorage& noc_model) {
+void BFSRouting::route_flow(NocRouterId src_router_id,
+                            NocRouterId sink_router_id,
+                            NocTrafficFlowId /*traffic_flow_id*/,
+                            std::vector<NocLinkId>& flow_route,
+                            const NocStorage& noc_model) {
     const NocRouter& src_router = noc_model.get_single_noc_router(src_router_id);
     const NocRouter& sink_router = noc_model.get_single_noc_router(sink_router_id);
 
@@ -15,7 +20,7 @@ void BFSRouting::route_flow(NocRouterId src_router_id, NocRouterId sink_router_i
      * Keeps track of which routers have been reached already
      * while traversing the NoC. This variable will help prevent 
      * the algorithm from getting stuck visiting routers that
-     * jave already been visited.
+     * have already been visited.
      * 
      */
     std::unordered_set<NocRouterId> visited_routers;
@@ -46,7 +51,7 @@ void BFSRouting::route_flow(NocRouterId src_router_id, NocRouterId sink_router_i
     }
 
     // Explore the NoC from the starting router and try to find a path to the destination router
-    // We finish searching when there are no more routers to process or we found the destination router
+    // We finish searching when there are no more routers to process, or we found the destination router
     while (!routers_to_process.empty() && !found_sink_router) {
         // get the next router to process
         NocRouterId processing_router = routers_to_process.front();
@@ -88,13 +93,17 @@ void BFSRouting::route_flow(NocRouterId src_router_id, NocRouterId sink_router_i
         generate_route(sink_router_id, flow_route, noc_model, router_parent_link);
     } else {
         // a path was not found so throw an error to the user
-        VPR_FATAL_ERROR(VPR_ERROR_OTHER, "No route could be found from starting router with id:'%d' and the destination router with id:'%d' using the breadth-first search routing algorithm.", src_router.get_router_user_id(), sink_router.get_router_user_id());
+        VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                        "No route could be found from starting router with id:'%d' and the destination router with id:'%d' using the breadth-first search routing algorithm.",
+                        src_router.get_router_user_id(),
+                        sink_router.get_router_user_id());
     }
-
-    return;
 }
 
-void BFSRouting::generate_route(NocRouterId start_router_id, std::vector<NocLinkId>& flow_route, const NocStorage& noc_model, const std::unordered_map<NocRouterId, NocLinkId>& router_parent_link) {
+void BFSRouting::generate_route(NocRouterId start_router_id,
+                                std::vector<NocLinkId>& flow_route,
+                                const NocStorage& noc_model,
+                                const std::unordered_map<NocRouterId, NocLinkId>& router_parent_link) {
     // The intermediate router being visited while tracing the path back from the destination router to the starting router in the flow.
     // Initially this is set to the router at the end of the path (destination router)
     NocRouterId curr_intermediate_router = start_router_id;
@@ -104,11 +113,11 @@ void BFSRouting::generate_route(NocRouterId start_router_id, std::vector<NocLink
     auto route_beginning = flow_route.begin();
 
     // get the parent link of the start router
-    std::unordered_map<NocRouterId, NocLinkId>::const_iterator curr_intermediate_router_parent_link = router_parent_link.find(curr_intermediate_router);
+    auto curr_intermediate_router_parent_link = router_parent_link.find(curr_intermediate_router);
 
-    // keep tracking baackwards from each router in the path until a router doesn't have a parent link (this means we reached the starting router in the flow)
+    // keep tracking backwards from each router in the path until a router doesn't have a parent link (this means we reached the starting router in the flow)
     while (curr_intermediate_router_parent_link != router_parent_link.end()) {
-        // add the parent link to the path. Since we are tracing backwards we need to store the links in fron of the last link.
+        // add the parent link to the path. Since we are tracing backwards we need to store the links in front of the last link.
         flow_route.emplace(route_beginning, curr_intermediate_router_parent_link->second);
 
         // update the reference to the beginning of the route
@@ -119,6 +128,4 @@ void BFSRouting::generate_route(NocRouterId start_router_id, std::vector<NocLink
         // now get the parent of the router we moved to
         curr_intermediate_router_parent_link = router_parent_link.find(curr_intermediate_router);
     }
-
-    return;
 }

vpr/src/noc/bfs_routing.h

@@ -14,13 +14,13 @@
  * traffic flow. Once the destination router is found a path from the source to
  * the destination router is generated. The main advantage of this algorithm is
  * that the found path from the source to the destination router uses the 
- * minimum number of links required within the NoC.
- * 
+ * minimum number of links required within the NoC. This algorithm does not
+ * guarantee deadlock freedom. In other words, the algorithm might generate
+ * routes that form cycles in channel dependency graph.
  */
 
 #include <vector>
 #include <unordered_map>
-#include <queue>
 
 #include "noc_routing.h"
 
@@ -41,6 +41,7 @@ class BFSRouting : public NocRouting {
      * @param sink_router_id The destination router of a traffic flow.
      * Identifies the ending point of the route within the NoC.This represents a 
      * physical router on the FPGA.
+     * @param traffic_flow_id The unique ID for the traffic flow being routed.
      * @param flow_route Stores the path returned by this fuction
      * as a series of NoC links found by 
      * a NoC routing algorithm between two routers in a traffic flow.
@@ -50,7 +51,11 @@ class BFSRouting : public NocRouting {
      * @param noc_model A model of the NoC. This is used to traverse the
      * NoC and find a route between the two routers.
      */
-    void route_flow(NocRouterId src_router_id, NocRouterId sink_router_id, std::vector<NocLinkId>& flow_route, const NocStorage& noc_model) override;
+    void route_flow(NocRouterId src_router_id,
+                    NocRouterId sink_router_id,
+                    NocTrafficFlowId traffic_flow_id,
+                    std::vector<NocLinkId>& flow_route,
+                    const NocStorage& noc_model) override;
 
     // internally used helper functions
   private:
@@ -76,7 +81,10 @@ class BFSRouting : public NocRouting {
      * router in the NoC (parent link is the link used to visit the router during
      * the BFS routing algorithm).
      */
-    void generate_route(NocRouterId sink_router_id, std::vector<NocLinkId>& flow_route, const NocStorage& noc_model, const std::unordered_map<NocRouterId, NocLinkId>& router_parent_link);
+    void generate_route(NocRouterId sink_router_id,
+                        std::vector<NocLinkId>& flow_route,
+                        const NocStorage& noc_model,
+                        const std::unordered_map<NocRouterId, NocLinkId>& router_parent_link);
 };
 
 #endif

vpr/src/noc/channel_dependency_graph.cpp

@@ -0,0 +1,98 @@
+
+#include "channel_dependency_graph.h"
+#include "vtr_assert.h"
+
+#include <stack>
+
+ChannelDependencyGraph::ChannelDependencyGraph(size_t n_links,
+                                               const vtr::vector<NocTrafficFlowId, std::vector<NocLinkId>>& traffic_flow_routes) {
+    adjacency_list_.clear();
+    // In channel dependency graph, vertices represent NoC links.
+    // reserve enough space so that all vertices can store their outgoing neighbors
+    adjacency_list_.resize(n_links);
+
+    /*
+     * A traffic flow travels through some NoC links. In channel dependency graph (CDG),
+     * consecutive NoC links travelled by the flow are connected using an edge.
+     * More specifically, for each pair of consecutive NoC links in a traffic flow route,
+     * there exists a directed edge from the NoC link travelled first to the other one.
+     * For example, if traffic flow T travels NoC links L0, L2, and L5 to reach its
+     * destination, we need to add (L0, L2) and (L2, L5) edges to CDG.
+     */
+
+    // iterate over all traffic flows and populate the channel dependency graph
+    for (const auto& traffic_flow_route : traffic_flow_routes) {
+        auto prev_link_id = NocLinkId::INVALID();
+        for (auto cur_link_id : traffic_flow_route) {
+            VTR_ASSERT(prev_link_id != cur_link_id);
+            if (prev_link_id != NocLinkId::INVALID()) {
+                adjacency_list_[prev_link_id].push_back(cur_link_id);
+            }
+            prev_link_id = cur_link_id;
+        }
+    }
+
+    // remove repetitive neighbors
+    for (auto& neighboring_nodes : adjacency_list_) {
+        // sort neighbors so that repetitive nodes are put beside each other
+        std::sort(neighboring_nodes.begin(), neighboring_nodes.end());
+
+        // remove consecutive duplicates
+        auto it = std::unique(neighboring_nodes.begin(), neighboring_nodes.end());
+
+        // erase the elements from the iterator to the end
+        neighboring_nodes.erase(it, neighboring_nodes.end());
+    }
+}
+
+bool ChannelDependencyGraph::has_cycles() {
+    // get the number vertices in CDG
+    const size_t n_vertices = adjacency_list_.size();
+
+    // indicates whether a node (NoC link) in CDG is visited during DFS
+    vtr::vector<NocLinkId, bool> visited(n_vertices, false);
+    // indicates whether a node (NoC links) is currently in stack
+    vtr::vector<NocLinkId, bool> on_stack(n_vertices, false);
+    // the stack used to perform graph traversal (DFS). Contains to-be-visited vertices
+    std::stack<NocLinkId> stack;
+
+    // iterate over all vertices (NoC links)
+    for (NocLinkId noc_link_id : adjacency_list_.keys()) {
+        // the node (NoC link) has already been visited
+        if (visited[noc_link_id]) {
+            continue;
+        }
+
+        // An un-visited node is found. Add to the stack
+        stack.push(noc_link_id);
+
+        // continue the traversal until the stack is empty
+        while (!stack.empty()) {
+            auto current_vertex_id = stack.top();
+
+            if (!visited[current_vertex_id]) {
+                on_stack[current_vertex_id] = true;
+                visited[current_vertex_id] = true;
+            } else { // the neighboring vertices have already been processed
+                // remove it from the stack
+                stack.pop();
+                on_stack[current_vertex_id] = false;
+            }
+
+            // get the outgoing edges of the current vertex
+            const auto& neighbor_ids = adjacency_list_[current_vertex_id];
+
+            // iterate over all outgoing neighbors
+            for (auto& neighbor_id : neighbor_ids) {
+                if (!visited[neighbor_id]) {
+                    stack.push(neighbor_id);
+                } else if (on_stack[neighbor_id]) { // the current vertex is pointing to one of its ancestors
+                    return true;
+                }
+            }
+        }
+    }
+
+    // if no vertex in the graph points to at least one of its ancestors, the graph does not have any cycles
+    return false;
+}

vpr/src/noc/channel_dependency_graph.h

@@ -0,0 +1,56 @@
+#ifndef VTR_CHANNEL_DEPENDENCY_GRAPH_H
+#define VTR_CHANNEL_DEPENDENCY_GRAPH_H
+
+/**
+ * @file
+ * @brief This file declares the ChannelDependencyGraph class.
+ *
+ * Overview
+ * ========
+ * The NoC routing algorithm might generate routes that cause a deadlock.
+ * The Channel Dependency Graph (CDG) is formed by associating a node with each
+ * link in the NoC topology. For each traffic flow route, we consider the
+ * consecutive links traversed to reach the destination. For each consecutively
+ * traversed link pair (Li, Lj) in the given topology, we add an directed edge from
+ * Vi to Vj, where Vi and Vj are nodes in CDG that are associated with Li and Lj.
+ * Absence of cycles in the formed CDG guarantees deadlock freedom.
+ *
+ * To learn more about channel dependency graph, refer to the following papers:
+ * 1) Glass, C. J., & Ni, L. M. (1992). The turn model for adaptive routing.
+ * ACM SIGARCH Computer Architecture News, 20(2), 278-287.
+ * 2) Dally, & Seitz. (1987). Deadlock-free message routing in multiprocessor
+ * interconnection networks. IEEE Transactions on computers, 100(5), 547-553.
+ */
+
+#include "vtr_vector.h"
+#include "noc_data_types.h"
+
+class ChannelDependencyGraph {
+  public:
+    ChannelDependencyGraph() = delete;
+
+    /**
+     * @brief Constructor
+     *
+     * @param n_links The total number of NoC links.
+     * @param traffic_flow_routes The route of each traffic flow generated
+     * by a routing algorithm.
+     */
+    ChannelDependencyGraph(size_t n_links,
+                           const vtr::vector<NocTrafficFlowId, std::vector<NocLinkId>>& traffic_flow_routes);
+
+    /**
+     * @brief Checks whether CDG has any cycles. A cycle implies that
+     * deadlocks are possible. If CDG has no cycles, deadlock freedom
+     * is guaranteed.
+     *
+     * @return True if the CDG has any cycles, otherwise false is returned.
+     */
+    bool has_cycles();
+
+  private:
+    /** An adjacency list used to represent channel dependency graph.*/
+    vtr::vector<NocLinkId, std::vector<NocLinkId>> adjacency_list_;
+};
+
+#endif //VTR_CHANNEL_DEPENDENCY_GRAPH_H