compute detailed noc latency cost

Author: soheilshahrouz

vpr/src/noc/noc_link.cpp

@@ -63,10 +63,15 @@ double NocLink::get_congested_bandwidth_ratio() const {
     return congested_bw_ratio;
 }
 
+double NocLink::get_latency() const {
+    return latency;
+}
+
 NocLinkId NocLink::get_link_id() const {
     return id;
 }
 
 NocLink::operator NocLinkId() const {
     return get_link_id();
-}
+}
+

vpr/src/noc/noc_link.h

@@ -98,6 +98,12 @@ class NocLink {
      */
     double get_congested_bandwidth_ratio() const;
 
+    /**
+     * @brief Returns the zero-load latency of the link.
+     * @return double Zero-load latency of the link.
+     */
+    double get_latency() const;
+
     /**
      * @brief Returns the unique link ID. The ID can be used to index
      * vtr::vector<NoCLinkId, ...> instances.

vpr/src/noc/noc_router.cpp

@@ -39,6 +39,10 @@ t_physical_tile_loc NocRouter::get_router_physical_location(void) const {
     return phy_loc;
 }
 
+double NocRouter::get_latency() const {
+    return router_latency;
+}
+
 ClusterBlockId NocRouter::get_router_block_ref(void) const {
     return router_block_ref;
 }

vpr/src/noc/noc_router.h

@@ -96,6 +96,8 @@ class NocRouter {
      */
     t_physical_tile_loc get_router_physical_location(void) const;
 
+    double get_latency() const;
+
     /**
      * @brief Gets the unique id of the router block that is current placed on the physical router
      * @return A ClusterBlockId that identifies a router block in the clustered netlist

vpr/src/noc/noc_storage.cpp

@@ -43,6 +43,18 @@ double NocStorage::get_noc_router_latency(void) const {
     return noc_router_latency;
 }
 
+bool NocStorage::get_detailed_router_latency() const {
+    return detailed_router_latency_;
+}
+
+bool NocStorage::get_detailed_link_latency() const {
+    return detailed_link_latency_;
+}
+
+bool NocStorage::get_detailed_link_bandwidth() const {
+    return detailed_link_bandwidth_;
+}
+
 const NocRouter& NocStorage::get_single_noc_router(NocRouterId id) const {
     return router_storage[id];
 }
@@ -130,29 +142,23 @@ void NocStorage::set_noc_link_bandwidth(double link_bandwidth) {
     for (auto& link : link_storage) {
         link.set_bandwidth(noc_link_bandwidth);
     }
-
-    return;
 }
 
 void NocStorage::set_noc_link_latency(double link_latency) {
     noc_link_latency = link_latency;
-    return;
 }
 
 void NocStorage::set_noc_router_latency(double router_latency) {
     noc_router_latency = router_latency;
-    return;
 }
 
 void NocStorage::set_device_grid_width(int grid_width) {
     device_grid_width = grid_width;
-    return;
 }
 
 void NocStorage::set_device_grid_spec(int grid_width, int grid_height) {
     device_grid_width = grid_width;
     layer_num_grid_locs = grid_width * grid_height;
-    return;
 }
 
 bool NocStorage::remove_link(NocRouterId src_router_id, NocRouterId sink_router_id) {
@@ -161,7 +167,7 @@ bool NocStorage::remove_link(NocRouterId src_router_id, NocRouterId sink_router_
 
     // check if the src router for the link to remove exists (within the id ranges). Otherwise, there is no point looking for the link
     if ((size_t)src_router_id < router_storage.size()) {
-        // get all the outgoing links of the provided sourcer router
+        // get all the outgoing links of the provided source router
         std::vector<NocLinkId>* source_router_outgoing_links = &router_link_list[src_router_id];
 
         // keeps track of the position of each outgoing link for the provided src router. When the id of the link to remove is found, this index can be used to remove it from the outgoing link vector.
@@ -199,26 +205,48 @@ bool NocStorage::remove_link(NocRouterId src_router_id, NocRouterId sink_router_
     return link_removed_status;
 }
 
-void NocStorage::finished_building_noc(void) {
+void NocStorage::finished_building_noc() {
     VTR_ASSERT_MSG(!built_noc, "NoC already built, cannot modify further.");
     built_noc = true;
 
-    return;
+    /* We go through all NoC routers in the router_storage and check if there are any
+     * two consecutive NoC routers whose latency is different. If such two routers are
+     * found, we set detailed_router_latency_ to True.
+     *
+     * The values of detailed_link_latency_ and detailed_link_bandwidth_ are determined
+     * in a similar way.
+     */
+
+    auto router_latency_it = std::adjacent_find(router_storage.begin(), router_storage.end(),
+                                                [](const NocRouter& a, const NocRouter& b) {
+                                                    return a.get_latency() != b.get_latency();
+                                                });
+    detailed_router_latency_ = (router_latency_it != router_storage.end());
+
+    auto link_latency_it = std::adjacent_find(link_storage.begin(), link_storage.end(),
+                                              [](const NocLink& a, const NocLink& b) {
+                                                  return a.get_latency() != b.get_latency();
+                                              });
+    detailed_link_latency_ = (link_latency_it != link_storage.end());
+
+    auto link_bandwidth_it = std::adjacent_find(link_storage.begin(), link_storage.end(),
+                                                [](const NocLink& a, const NocLink& b) {
+                                                    return a.get_bandwidth() != b.get_bandwidth();
+                                                });
+    detailed_link_bandwidth_ = (link_bandwidth_it != link_storage.end());
 }
 
-void NocStorage::clear_noc(void) {
+void NocStorage::clear_noc() {
     router_storage.clear();
     link_storage.clear();
     router_link_list.clear();
     grid_location_to_router_id.clear();
 
     built_noc = false;
-
-    return;
 }
 
 NocRouterId NocStorage::convert_router_id(int id) const {
-    std::unordered_map<int, NocRouterId>::const_iterator result = router_id_conversion_table.find(id);
+    auto result = router_id_conversion_table.find(id);
 
     if (result == router_id_conversion_table.end()) {
         VPR_FATAL_ERROR(VPR_ERROR_OTHER, "Cannot convert router with id:%d. The router was not found within the NoC.", id);

vpr/src/noc/noc_storage.h

@@ -133,6 +133,10 @@ class NocStorage {
      */
     double noc_router_latency;
 
+    bool detailed_router_latency_;
+    bool detailed_link_latency_;
+    bool detailed_link_bandwidth_;
+
     /**
      * @brief Internal reference to the device grid width. This is necessary
      * to compute a unique key for a given grid location which we can then use
@@ -235,6 +239,12 @@ class NocStorage {
 
     double get_noc_router_latency(void) const;
 
+    bool get_detailed_router_latency() const;
+
+    bool get_detailed_link_latency() const;
+
+    bool get_detailed_link_bandwidth() const;
+
     // getters for  routers
 
     /**
@@ -342,34 +352,26 @@ class NocStorage {
 
     /**
      * @brief Set the maximum allowable bandwidth for a link
-     * within the NoC.
-     * 
+     * within the NoC
      */
-
     void set_noc_link_bandwidth(double link_bandwidth);
 
     /**
      * @brief Set the latency of traversing through a link in
      * the NoC.
-     * 
      */
-
     void set_noc_link_latency(double link_latency);
 
     /**
      * @brief Set the latency of traversing through a router in
      * the NoC.
-     * 
      */
-
     void set_noc_router_latency(double router_latency);
 
     /**
      * @brief Set the internal reference to the device
      * grid width.
-     * 
      */
-
     void set_device_grid_width(int grid_width);
 
     void set_device_grid_spec(int grid_width, int grid_height);
@@ -404,7 +406,7 @@ class NocStorage {
      * no future changes can be made.
      * 
      */
-    void finished_building_noc(void);
+    void finished_building_noc();
 
     /**
      * @brief Resets the NoC by clearing all internal datastructures.
@@ -413,7 +415,7 @@ class NocStorage {
      * recommended to run this function before building the NoC.
      * 
      */
-    void clear_noc(void);
+    void clear_noc();
 
     /**
      * @brief Given a user id of a router, this function converts

vpr/src/place/noc_place_utils.cpp

@@ -552,19 +552,49 @@ double calculate_traffic_flow_aggregate_bandwidth_cost(const std::vector<NocLink
 std::pair<double, double> calculate_traffic_flow_latency_cost(const std::vector<NocLinkId>& traffic_flow_route,
                                                               const NocStorage& noc_model,
                                                               const t_noc_traffic_flow& traffic_flow_info) {
-    // there will always be one more router than links in a traffic flow
-    int num_of_links_in_traffic_flow = traffic_flow_route.size();
-    int num_of_routers_in_traffic_flow = num_of_links_in_traffic_flow + 1;
-    double max_latency = traffic_flow_info.max_traffic_flow_latency;
 
-    // latencies of the noc
-    double noc_link_latency = noc_model.get_noc_link_latency();
-    double noc_router_latency = noc_model.get_noc_router_latency();
+    double noc_link_latency_component = 0.0;
+    if (noc_model.get_detailed_link_latency()) {
+        for (auto noc_link_id : traffic_flow_route) {
+            const NocLink& noc_link = noc_model.get_single_noc_link(noc_link_id);
+            double noc_link_latency = noc_link.get_latency();
+            noc_link_latency_component += noc_link_latency;
+        }
+    } else {
+        auto num_of_links_in_traffic_flow = (double)traffic_flow_route.size();
+        double noc_link_latency = noc_model.get_noc_link_latency();
+        noc_link_latency_component = noc_link_latency * num_of_links_in_traffic_flow;
+    }
+
+    double noc_router_latency_component = 0.0;
+
+    if (noc_model.get_detailed_router_latency()) {
+        NocLinkId first_noc_link_id = traffic_flow_route[0];
+        const NocLink& first_noc_link = noc_model.get_single_noc_link(first_noc_link_id);
+        NocRouterId source_noc_router_id = first_noc_link.get_source_router();
+        const NocRouter& source_noc_router = noc_model.get_single_noc_router(source_noc_router_id);
+        noc_router_latency_component = source_noc_router.get_latency();
+
+        for (auto noc_link_id : traffic_flow_route) {
+            const NocLink& noc_link = noc_model.get_single_noc_link(noc_link_id);
+            const NocRouterId sink_router_id = noc_link.get_sink_router();
+            const NocRouter& sink_router = noc_model.get_single_noc_router(sink_router_id);
+            double noc_router_latency = sink_router.get_latency();
+            noc_router_latency_component += noc_router_latency;
+        }
+    } else {
+        // there will always be one more router than links in a traffic flow
+        auto num_of_routers_in_traffic_flow = (double)traffic_flow_route.size() + 1;
+        double noc_router_latency = noc_model.get_noc_router_latency();
+        noc_router_latency_component = noc_router_latency * num_of_routers_in_traffic_flow;
+    }
+
 
-    // calculate the traffic flow latency
-    double latency = (noc_link_latency * num_of_links_in_traffic_flow) + (noc_router_latency * num_of_routers_in_traffic_flow);
+    // calculate the total traffic flow latency
+    double latency = noc_router_latency_component + noc_link_latency_component;
 
     // calculate the traffic flow latency overrun
+    double max_latency = traffic_flow_info.max_traffic_flow_latency;
     double latency_overrun = std::max(latency - max_latency, 0.);
 
     // scale the latency cost by its priority to indicate its importance