remove NoC-wide link bandwidth member variable and getter

Author: soheilshahrouz

vpr/src/draw/draw_noc.cpp

@@ -67,8 +67,6 @@ void draw_noc(ezgl::renderer* g) {
     draw_noc_links(g, noc_router_logical_type, noc_link_colors, noc_connection_marker_bbox, list_of_noc_link_shift_directions);
 
     draw_noc_connection_marker(g, router_list, noc_connection_marker_bbox);
-
-    return;
 }
 
 /*
@@ -78,55 +76,42 @@ void draw_noc_usage(vtr::vector<NocLinkId, ezgl::color>& noc_link_colors) {
     t_draw_state* draw_state = get_draw_state_vars();
     auto& noc_ctx = g_vpr_ctx.noc();
 
-    // get the maximum badnwidth per link
-    double max_noc_link_bandwidth = noc_ctx.noc_model.get_noc_link_bandwidth();
-
     // check to see if a color map was already created previously
     if (draw_state->noc_usage_color_map == nullptr) {
-        // we havent created a color map yet for the noc link usage, so create it here
+        // we haven't created a color map yet for the noc link usage, so create it here
         // the color map creates a color spectrum that gradually changes from a dark to light color. Where a dark color represents low noc link usage (low bandwidth) and a light color represents high noc link usage (high bandwidth)
         // The color map needs a min and max value to generate the color range.
         // The noc usage is calculated by taking the ratio of the links current bandwidth over the maximum allowable bandwidth
-        // for the NoC, the min value is 0, since you cannot go lower than 0 badnwidth.
+        // for the NoC, the min value is 0, since you cannot go lower than 0 bandwidth.
         // The max value is going to be 1 and represents the case where the link is used to full capacity on the noc link (as provided by the user)
         draw_state->noc_usage_color_map = std::make_shared<vtr::PlasmaColorMap>(0.0, 1.0);
     }
 
-    // get the list of links in the NoC
-    const vtr::vector<NocLinkId, NocLink>& noc_link_list = noc_ctx.noc_model.get_noc_links();
-
-    // store each links bandwidth usage
-    double link_bandwidth_usage;
-
     // represents the color to draw each noc link
     ezgl::color current_noc_link_color;
 
-    // now we need to determine the colors for each link
-    for (int link = 0; link < (int)noc_link_list.size(); link++) {
-        // get the current link id
-        NocLinkId link_id(link);
+    for (const auto& noc_link : noc_ctx.noc_model.get_noc_links()) {
+        NocLinkId link_id = noc_link.get_link_id();
 
-        // only update the color of the link if it wasnt updated previously
+        // only update the color of the link if it wasn't updated previously
         if (noc_link_colors[link_id] == ezgl::BLACK) {
             // if we are here then the link was not updated previously, so assign the color here
 
             //get the current link bandwidth usage (ratio calculation)
-            link_bandwidth_usage = (noc_link_list[link_id].get_bandwidth_usage()) / max_noc_link_bandwidth;
+            double link_bandwidth_usage_ratio = (noc_link.get_bandwidth_usage()) / noc_link.get_bandwidth();
 
             // check if the link is being overused and if it is then cap it at 1.0
-            if (link_bandwidth_usage > 1.0) {
-                link_bandwidth_usage = 1.0;
+            if (link_bandwidth_usage_ratio > 1.0) {
+                link_bandwidth_usage_ratio = 1.0;
             }
 
-            // get the corresponding color that represents the link bandwidth usgae
-            current_noc_link_color = to_ezgl_color(draw_state->noc_usage_color_map->color(link_bandwidth_usage));
+            // get the corresponding color that represents the link bandwidth usage
+            current_noc_link_color = to_ezgl_color(draw_state->noc_usage_color_map->color(link_bandwidth_usage_ratio));
 
             // set the colors of the link
             noc_link_colors[link_id] = current_noc_link_color;
         }
     }
-
-    return;
 }
 
 /*
@@ -158,7 +143,7 @@ ezgl::rectangle get_noc_connection_marker_bbox(const t_logical_block_type_ptr no
      * We do the following to calculate the position of the marker:
      * 1. Get the area of the larger router tile
      * 2. Calculate the area of the marker (based on a predefined percentage of the area of the larger noc tile)
-     * 3. The marker is a square, so we can can calculate the lengths 
+     * 3. The marker is a square, so we can calculate the lengths
      * of the sides of the marker
      * 4. Divide the side length by 2 and subtract this from the x & y coordinates of the center of the larger noc router tile. This is the bottom left corner of the rectangle.
      * 5. Then add the side length to the x & y coordinate of the center of the larger noc router tile. THis is the top right corner of the rectangle.    
@@ -188,15 +173,11 @@ void draw_noc_connection_marker(ezgl::renderer* g, const vtr::vector<NocRouterId
     t_draw_coords* draw_coords = get_draw_coords_vars();
     t_draw_state* draw_state = get_draw_state_vars();
 
-    int router_grid_position_x = 0;
-    int router_grid_position_y = 0;
-    int router_grid_position_layer = 0;
-
     ezgl::rectangle updated_connection_marker_bbox;
 
     // go through the routers and create the connection marker
-    for (auto router = router_list.begin(); router != router_list.end(); router++) {
-        router_grid_position_layer = router->get_router_layer_position();
+    for (const auto & router : router_list) {
+        int router_grid_position_layer = router.get_router_layer_position();
 
         t_draw_layer_display marker_box_visibility = draw_state->draw_layer_display[router_grid_position_layer];
         if (!marker_box_visibility.visible) {
@@ -206,17 +187,15 @@ void draw_noc_connection_marker(ezgl::renderer* g, const vtr::vector<NocRouterId
         //set the color of the marker with the layer transparency
         g->set_color(ezgl::BLACK, marker_box_visibility.alpha);
 
-        router_grid_position_x = router->get_router_grid_position_x();
-        router_grid_position_y = router->get_router_grid_position_y();
+        int router_grid_position_x = router.get_router_grid_position_x();
+        int router_grid_position_y = router.get_router_grid_position_y();
 
         // get the coordinates to draw the marker given the current routers tile position
         updated_connection_marker_bbox = connection_marker_bbox + ezgl::point2d(draw_coords->tile_x[router_grid_position_x], draw_coords->tile_y[router_grid_position_y]);
 
         // draw the marker
         g->fill_rectangle(updated_connection_marker_bbox);
     }
-
-    return;
 }
 
 /*
@@ -307,8 +286,6 @@ void draw_noc_links(ezgl::renderer* g, t_logical_block_type_ptr noc_router_logic
         //draw a line between the center of the two routers this link connects
         g->draw_line(link_coords.start, link_coords.end);
     }
-
-    return;
 }
 
 void determine_direction_to_shift_noc_links(vtr::vector<NocLinkId, NocLinkShift>& list_of_noc_link_shift_directions) {
@@ -343,8 +320,6 @@ void determine_direction_to_shift_noc_links(vtr::vector<NocLinkId, NocLinkShift>
             list_of_noc_link_shift_directions[parallel_link] = NocLinkShift::BOTTOM_SHIFT;
         }
     }
-
-    return;
 }
 
 NocLinkType determine_noc_link_type(ezgl::point2d link_start_point, ezgl::point2d link_end_point) {
@@ -488,13 +463,11 @@ void shift_noc_link(noc_link_draw_coords& link_coords, NocLinkShift link_shift_d
                 link_coords.start.y += noc_connection_marker_quarter_height;
                 link_coords.end.y += noc_connection_marker_quarter_height;
             }
-            // dont change anything if we arent shifting at all
+            // don't change anything if we aren't shifting at all
             break;
         default:
             break;
     }
-
-    return;
 }
 
 #endif

vpr/src/noc/noc_storage.cpp

@@ -31,10 +31,6 @@ int NocStorage::get_number_of_noc_links(void) const {
     return link_storage.size();
 }
 
-double NocStorage::get_noc_link_bandwidth(void) const {
-    return noc_link_bandwidth;
-}
-
 double NocStorage::get_noc_link_latency(void) const {
     return noc_link_latency;
 }
@@ -136,11 +132,10 @@ void NocStorage::add_link(NocRouterId source, NocRouterId sink, double bandwidth
 }
 
 void NocStorage::set_noc_link_bandwidth(double link_bandwidth) {
-    noc_link_bandwidth = link_bandwidth;
 
     // Iterate over all links and set their bandwidth
     for (auto& link : link_storage) {
-        link.set_bandwidth(noc_link_bandwidth);
+        link.set_bandwidth(link_bandwidth);
     }
 }
 
@@ -301,8 +296,6 @@ void NocStorage::echo_noc(char* file_name) const {
     fprintf(fp, "NoC Constraints:\n");
     fprintf(fp, "--------------------------------------------------------------\n");
     fprintf(fp, "\n");
-    fprintf(fp, "Maximum NoC Link Bandwidth: %f\n", noc_link_bandwidth);
-    fprintf(fp, "\n");
     fprintf(fp, "NoC Link Latency: %f\n", noc_link_latency);
     fprintf(fp, "\n");
     fprintf(fp, "NoC Router Latency: %f\n", noc_router_latency);
@@ -318,21 +311,23 @@ void NocStorage::echo_noc(char* file_name) const {
         fprintf(fp, "Router %d:\n", router.get_router_user_id());
         // if the router tile is larger than a single grid, the position represents the bottom left corner of the tile
         fprintf(fp, "Equivalent Physical Tile Grid Position -> (%d,%d)\n", router.get_router_grid_position_x(), router.get_router_grid_position_y());
-        fprintf(fp, "Router Connections ->");
+        fprintf(fp, "Router Connections (destination router id, link bandwidth, link latency) ->");
 
         auto& router_connections = this->get_noc_router_connections(this->convert_router_id(router.get_router_user_id()));
 
         // go through the outgoing links of the current router and print the connecting router
         for (auto router_connection : router_connections) {
-            const NocRouterId connecting_router_id = get_single_noc_link(router_connection).get_sink_router();
+            const auto& link = get_single_noc_link(router_connection);
+            const NocRouterId connecting_router_id = link.get_sink_router();
 
-            fprintf(fp, " %d", get_single_noc_router(connecting_router_id).get_router_user_id());
+            fprintf(fp, " (%d, %g, %g)",
+                    get_single_noc_router(connecting_router_id).get_router_user_id(),
+                    link.get_bandwidth(),
+                    link.get_latency());
         }
 
         fprintf(fp, "\n\n");
     }
 
     fclose(fp);
-
-    return;
 }

vpr/src/noc/noc_storage.h

@@ -116,11 +116,6 @@ class NocStorage {
      */
     bool built_noc;
 
-    /**
-     * @brief Represents the maximum allowed bandwidth for the links in the NoC (in bps)
-     */
-    double noc_link_bandwidth;
-
     /**
      * @brief Represents the delay expected when going through a link (in
      * seconds)
@@ -237,14 +232,6 @@ class NocStorage {
      */
     int get_number_of_noc_links() const;
 
-    /**
-     * @brief Get the maximum allowable bandwidth for a link
-     * within the NoC.
-     * 
-     * @return a numeric value that represents the link bandwidth in bps
-     */
-    double get_noc_link_bandwidth() const;
-
     /**
      * @brief Get the latency of traversing through a link in
      * the NoC.
@@ -460,7 +447,6 @@ class NocStorage {
      * used. In the detailed model, instead of associating a single latency or
      * bandwidth value with all NoC routers or links, each NoC router or link
      * has its specific value.
-     * 
      */
     void finished_building_noc();
 
@@ -469,7 +455,6 @@ class NocStorage {
      * This includes deleting all routers and links. Also all internal
      * IDs are removed (the is conversion table is cleared). It is
      * recommended to run this function before building the NoC.
-     * 
      */
     void clear_noc();
 
@@ -530,10 +515,10 @@ class NocStorage {
      * @param grid_position_x The horizontal position on the FPGA of the physical
      * tile that this router represents.
      * 
-     * @param grid_position_y The vertical position on the FPGA of the phyical
+     * @param grid_position_y The vertical position on the FPGA of the physical
      * tile that this router represents.
      * 
-     * @param layer_position The layer number of the phyical
+     * @param layer_position The layer number of the physical
      * tile that this router represents.
      *  
      * @return int Represents a unique key that can be used to identify a

vpr/test/test_noc_place_utils.cpp

@@ -522,15 +522,16 @@ TEST_CASE("test_find_affected_noc_routers_and_update_noc_costs, test_commit_noc_
     noc_opts.noc_latency_weighting = dist_3(double_engine);
     noc_opts.noc_congestion_weighting = dist_3(double_engine);
 
+    constexpr double link_bandwidth = 1.0;
+
     // setting the NoC parameters
     noc_ctx.noc_model.set_noc_link_latency(1);
     noc_ctx.noc_model.set_noc_router_latency(1);
-    noc_ctx.noc_model.set_noc_link_bandwidth(1);
+    noc_ctx.noc_model.set_noc_link_bandwidth(link_bandwidth);
 
     // needs to be the same as above
     const double router_latency = noc_ctx.noc_model.get_noc_router_latency();
     const double link_latency = noc_ctx.noc_model.get_noc_link_latency();
-    const double link_bandwidth = noc_ctx.noc_model.get_noc_link_bandwidth();
 
     // keeps track of which hard router each cluster block is placed
     vtr::vector<ClusterBlockId, NocRouterId> router_where_cluster_is_placed;