Merge pull request #2179 from verilog-to-routing/track_dir_utilization

Print WL Information Based on Direction and Length

Author: vaughnbetz

vpr/src/route/segment_stats.cpp

@@ -20,10 +20,8 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
      * are counted as full-length segments (e.g. length 4 even if the last 2    *
      * units of wire were chopped off by the chip edge).                        */
 
-    int length, max_segment_length;
+    int max_segment_length;
     RRIndexedDataId cost_index;
-    int *seg_occ_by_length, *seg_cap_by_length; /* [0..max_segment_length] */
-    int *seg_occ_by_type, *seg_cap_by_type;     /* [0..num_segment-1]      */
     float utilization;
 
     auto& device_ctx = g_vpr_ctx.device();
@@ -41,37 +39,65 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
         max_segment_name_length = std::max(max_segment_name_length, static_cast<int>(segment_inf[seg_type].name.size()));
     }
 
-    seg_occ_by_length = new int[max_segment_length + 1];
-    seg_cap_by_length = new int[max_segment_length + 1];
+    std::map<e_parallel_axis, std::vector<int>> directed_occ_by_length = {
+        {X_AXIS, std::vector<int>(max_segment_length + 1, 0)},
+        {Y_AXIS, std::vector<int>(max_segment_length + 1, 0)}};
 
-    for (int i = 0; i < max_segment_length + 1; i++) {
-        seg_occ_by_length[i] = 0;
-        seg_cap_by_length[i] = 0;
-    }
-
-    seg_occ_by_type = new int[segment_inf.size()];
-    seg_cap_by_type = new int[segment_inf.size()];
-
-    for (size_t i = 0; i < segment_inf.size(); i++) {
-        seg_occ_by_type[i] = 0;
-        seg_cap_by_type[i] = 0;
-    }
+    std::map<e_parallel_axis, std::vector<int>> directed_cap_by_length = {
+        {X_AXIS, std::vector<int>(max_segment_length + 1, 0)},
+        {Y_AXIS, std::vector<int>(max_segment_length + 1, 0)}};
 
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         size_t inode = (size_t)rr_id;
-        if (rr_graph.node_type(rr_id) == CHANX || rr_graph.node_type(rr_id) == CHANY) {
+        auto node_type = rr_graph.node_type(rr_id);
+        if (node_type == CHANX || node_type == CHANY) {
             cost_index = rr_graph.node_cost_index(rr_id);
             size_t seg_type = device_ctx.rr_indexed_data[cost_index].seg_index;
-
+            int length = -1;
             if (!segment_inf[seg_type].longline)
                 length = segment_inf[seg_type].length;
             else
                 length = LONGLINE;
             const short& inode_capacity = rr_graph.node_capacity(rr_id);
-            seg_occ_by_length[length] += route_ctx.rr_node_route_inf[inode].occ();
-            seg_cap_by_length[length] += inode_capacity;
-            seg_occ_by_type[seg_type] += route_ctx.rr_node_route_inf[inode].occ();
-            seg_cap_by_type[seg_type] += inode_capacity;
+            int occ = route_ctx.rr_node_route_inf[inode].occ();
+            auto ax = (node_type == CHANX) ? X_AXIS : Y_AXIS;
+            directed_occ_by_length[ax][length] += occ;
+            directed_cap_by_length[ax][length] += inode_capacity;
+        }
+    }
+
+    VTR_LOG("\n");
+    VTR_LOG("Total Number of Wiring Segments by Direction: direction length number\n");
+    VTR_LOG("                                              --------- ------ -------\n");
+    for (int length = 0; length <= max_segment_length; length++) {
+        for (auto ax : {X_AXIS, Y_AXIS}) {
+            std::string ax_name = (ax == X_AXIS) ? "X" : "Y";
+            if (directed_cap_by_length[ax][length] != 0) {
+                std::string length_str = (length == LONGLINE) ? "longline" : std::to_string(length);
+                VTR_LOG("                                              %s%s %s%s %6d\n",
+                        std::string(std::max(9 - (int)ax_name.length(), 0), ' ').c_str(),
+                        ax_name.c_str(),
+                        std::string(std::max(6 - (int)length_str.length(), 0), ' ').c_str(),
+                        length_str.c_str(),
+                        directed_cap_by_length[ax][length]);
+            }
+        }
+    }
+
+    for (auto ax : {X_AXIS, Y_AXIS}) {
+        std::string ax_name = (ax == X_AXIS) ? "X" : "Y";
+        VTR_LOG("\n");
+        VTR_LOG("%s - Directed Wiring Segment usage by length: length utilization\n", ax_name.c_str());
+        VTR_LOG("                                             ------ -----------\n");
+        for (int length = 0; length <= max_segment_length; length++) {
+            if (directed_cap_by_length[ax][length] != 0) {
+                std::string length_str = (length == LONGLINE) ? "longline" : std::to_string(length);
+                utilization = (float)directed_occ_by_length[ax][length] / (float)directed_cap_by_length[ax][length];
+                VTR_LOG("                                       %s%s %11.3g\n",
+                        std::string(std::max(6 - (int)length_str.length(), 0), ' ').c_str(),
+                        length_str.c_str(),
+                        utilization);
+            }
         }
     }
 
@@ -80,33 +106,18 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
     VTR_LOG("                               %s ---- -----------\n", std::string(std::max(4, max_segment_name_length), '-').c_str());
 
     for (size_t seg_type = 0; seg_type < segment_inf.size(); seg_type++) {
-        if (seg_cap_by_type[seg_type] != 0) {
+        int seg_length = segment_inf[seg_type].length;
+        if (directed_cap_by_length[X_AXIS][seg_length] != 0 || directed_cap_by_length[Y_AXIS][seg_length] != 0) {
             std::string seg_name = segment_inf[seg_type].name;
             int seg_name_size = static_cast<int>(seg_name.size());
-            utilization = (float)seg_occ_by_type[seg_type] / (float)seg_cap_by_type[seg_type];
+            int occ = 0;
+            int cap = 0;
+            for (auto ax : {X_AXIS, Y_AXIS}) {
+                occ += directed_occ_by_length[ax][seg_length];
+                cap = directed_cap_by_length[ax][seg_length];
+            }
+            utilization = (float)occ / (float)cap;
             VTR_LOG("                               %s%s %4d %11.3g\n", std::string(std::max(4 - seg_name_size, (max_segment_name_length - seg_name_size)), ' ').c_str(), seg_name.c_str(), seg_type, utilization);
         }
     }
-
-    VTR_LOG("\n");
-    VTR_LOG("Segment usage by length: length utilization\n");
-    VTR_LOG("                         ------ -----------\n");
-
-    for (length = 1; length <= max_segment_length; length++) {
-        if (seg_cap_by_length[length] != 0) {
-            utilization = (float)seg_occ_by_length[length] / (float)seg_cap_by_length[length];
-            VTR_LOG("                         %6d %11.3g\n", length, utilization);
-        }
-    }
-    VTR_LOG("\n");
-
-    if (seg_cap_by_length[LONGLINE] != 0) {
-        utilization = (float)seg_occ_by_length[LONGLINE] / (float)seg_cap_by_length[LONGLINE];
-        VTR_LOG("   longline                 %5.3g\n", utilization);
-    }
-
-    delete[](seg_occ_by_length);
-    delete[](seg_cap_by_length);
-    delete[](seg_occ_by_type);
-    delete[](seg_cap_by_type);
 }