Merge branch 'final_graphics_clean_up' of https://github.com/verilog-to-routing/vtr-verilog-to-routing into final_graphics_clean_up

SamuelHo10 · SamuelHo10 · commit b581c63d24be · 2025-08-22T16:27:46.000-04:00
diff --git a/libs/librrgraph/src/utils/alloc_and_load_rr_indexed_data.cpp b/libs/librrgraph/src/utils/alloc_and_load_rr_indexed_data.cpp
@@ -1,5 +1,6 @@
 #include "alloc_and_load_rr_indexed_data.h"
 
+#include <algorithm>
 #include <cmath> /* Needed only for sqrt call (remove if sqrt removed) */
 #include <fstream>
 #include <iomanip>
@@ -592,8 +593,10 @@ static void load_rr_indexed_data_T_values(const RRGraphView& rr_graph,
             auto switch_Cinternal_total_histogram = build_histogram(switch_Cinternal_total[RRIndexedDataId(cost_index)], 10);
 
             // Sort Rnode and Cnode
-            float Cnode = vtr::median(C_total[RRIndexedDataId(cost_index)]);
-            float Rnode = vtr::median(R_total[RRIndexedDataId(cost_index)]);
+            std::sort(C_total[RRIndexedDataId(cost_index)].begin(), C_total[RRIndexedDataId(cost_index)].end());
+            std::sort(R_total[RRIndexedDataId(cost_index)].begin(), R_total[RRIndexedDataId(cost_index)].end());
+            float Cnode = vtr::median_presorted<float>(C_total[RRIndexedDataId(cost_index)]);
+            float Rnode = vtr::median_presorted<float>(R_total[RRIndexedDataId(cost_index)]);
             float Rsw = get_histogram_mode(switch_R_total_histogram);
             float Tsw = get_histogram_mode(switch_T_total_histogram);
             float Cinternalsw = get_histogram_mode(switch_Cinternal_total_histogram);
diff --git a/libs/libvtrutil/src/vtr_math.cpp b/libs/libvtrutil/src/vtr_math.cpp
@@ -1,5 +1,4 @@
 #include <map>
-#include <algorithm>
 
 #include "vtr_assert.h"
 #include "vtr_error.h"
@@ -22,19 +21,6 @@ int ipow(int base, int exp) {
     return result;
 }
 
-float median(std::vector<float> vector) {
-    VTR_ASSERT(vector.size() > 0);
-
-    std::sort(vector.begin(), vector.end());
-
-    auto size = vector.size();
-    if (size % 2 == 0) {
-        return (float)(vector[size / 2 - 1] + vector[size / 2]) / 2;
-    }
-
-    return (float)vector[size / 2];
-}
-
 /**
  * @brief Linear interpolation/Extrapolation 
  *
diff --git a/libs/libvtrutil/src/vtr_math.h b/libs/libvtrutil/src/vtr_math.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <algorithm>
+#include <iterator>
 #include <map>
 #include <vector>
 #include <cmath>
@@ -16,9 +18,6 @@ namespace vtr {
 ///@brief Calculates the value pow(base, exp)
 int ipow(int base, int exp);
 
-///@brief Returns the median of an input vector.
-float median(std::vector<float> vector);
-
 ///@brief Linear interpolation/Extrapolation
 template<typename X, typename Y>
 Y linear_interpolate_or_extrapolate(const std::map<X, Y>* xy_map, X requested_x);
@@ -35,23 +34,57 @@ T safe_ratio(T numerator, T denominator) {
     return numerator / denominator;
 }
 
-///@brief Returns the median of the elements in range [first, last]
-template<typename InputIterator>
-double median(InputIterator first, InputIterator last) {
-    auto len = std::distance(first, last);
-    auto iter = first + len / 2;
-
-    if (len % 2 == 0) {
-        return (*iter + *(iter + 1)) / 2;
-    } else {
+///@brief Returns the median of the elements in range [first, last)
+///       If there are an odd number of elements in the range, returns the
+///       average of the two middle elements (equal distance from the start and end).
+/// NOTE: This method assumes that the container that first and last point to are
+///       pre-sorted
+template<typename ResultTy = double, typename InputIterator>
+ResultTy median_presorted(const InputIterator first, const InputIterator last) {
+    // If the distance between first and last is 0 (meaning the set is empty),
+    // return a quiet NaN. This should be handled by the user of this code.
+    // NOTE: This returns a NaN of double type.
+    if (std::distance(first, last) == 0)
+        return std::nan("");
+
+    // Get the distance from the first element to the last element that is included
+    // in the set of elements that we are getting the median of. Since "last" is
+    // implicitly not included in this set, this is the distance from first to
+    // last minus 1.
+    auto dist_to_last_inclusive = std::distance(first, last) - 1;
+
+    if (dist_to_last_inclusive % 2 == 0) {
+        // If the distance to the last inclusive element is even, then there is
+        // only a single median element. Return it.
+        auto iter = first + (dist_to_last_inclusive / 2);
         return *iter;
+    } else {
+        // If the distance to the last inclusive element is odd, then there are
+        // two median elements. Return the average of the two.
+        auto iter_1 = first + (dist_to_last_inclusive / 2);
+        auto iter_2 = first + (dist_to_last_inclusive / 2) + 1;
+        // Note: To ensure that the division works properly, need to cast one
+        //       of the operands to the result type.
+        return static_cast<ResultTy>(*iter_1 + *iter_2) / 2;
     }
 }
 
-///@brief Returns the median of a whole container
-template<typename Container>
-double median(Container c) {
-    return median(std::begin(c), std::end(c));
+///@brief Returns the median of a whole container, assuming the container has
+///       not been pre-sorted.
+/// Note: This function is pass by value since the container needs to be
+///       sorted. If the container is already sorted, use median_presorted to
+///       avoid the copy.
+template<typename ResultTy = double, typename Container>
+ResultTy median(Container c) {
+    std::sort(std::begin(c), std::end(c));
+    return median_presorted<ResultTy>(std::begin(c), std::end(c));
+}
+
+///@brief Returns the median of a whole container, assuming that it is already
+///       sorted.
+template<typename ResultTy = double, typename Container>
+ResultTy median_presorted(const Container &c) {
+    return median_presorted<ResultTy>(std::begin(c), std::end(c));
 }
 
 /**
@@ -66,7 +99,7 @@ double median(Container c) {
  *      geomean = exp( (1 / n) * (log(v_1) + log(v_2) + ... + log(v_n)))
  */
 template<typename InputIterator>
-double geomean(InputIterator first, InputIterator last, double init = 1.) {
+double geomean(const InputIterator first, const InputIterator last, double init = 1.) {
     double log_sum = std::log(init);
     size_t n = 0;
     for (auto iter = first; iter != last; ++iter) {
@@ -83,13 +116,13 @@ double geomean(InputIterator first, InputIterator last, double init = 1.) {
 
 ///@brief Returns the geometric mean of a whole container
 template<typename Container>
-double geomean(Container c) {
+double geomean(const Container &c) {
     return geomean(std::begin(c), std::end(c));
 }
 
-///@brief Returns the arithmatic mean of the elements in range [first, last]
+///@brief Returns the arithmatic mean of the elements in range [first, last)
 template<typename InputIterator>
-double arithmean(InputIterator first, InputIterator last, double init = 0.) {
+double arithmean(const InputIterator first, const InputIterator last, double init = 0.) {
     double sum = init;
     size_t n = 0;
     for (auto iter = first; iter != last; ++iter) {
@@ -106,7 +139,7 @@ double arithmean(InputIterator first, InputIterator last, double init = 0.) {
 
 ///@brief Returns the aritmatic mean of a whole container
 template<typename Container>
-double arithmean(Container c) {
+double arithmean(const Container &c) {
     return arithmean(std::begin(c), std::end(c));
 }
 
diff --git a/libs/libvtrutil/test/test_math.cpp b/libs/libvtrutil/test/test_math.cpp
@@ -1,4 +1,6 @@
+#include <cmath>
 #include <limits>
+#include <vector>
 
 #include "catch2/catch_test_macros.hpp"
 #include "catch2/catch_approx.hpp"
@@ -56,3 +58,67 @@ TEST_CASE("Is Close", "[vtr_math]") {
     REQUIRE(vtr::isclose(32.2, 32.4, 1e-9, 0.2));
     REQUIRE(!vtr::isclose(32.2, 32.4, 1e-9, 0.1));
 }
+
+TEST_CASE("Median", "[vtr_math]") {
+    // Check the median of a vector with a singular value.
+    std::vector<double> single_vec = {1.0};
+    REQUIRE(vtr::median(single_vec) == 1.0);
+    REQUIRE(vtr::median_presorted(single_vec) == 1.0);
+
+    // Check the median of a vector with two elements.
+    std::vector<double> double_vec = {1.0, 2.0};
+    REQUIRE(vtr::median(double_vec) == 1.5);
+    REQUIRE(vtr::median_presorted(double_vec) == 1.5);
+
+    // Check the median of a vector with an odd length.
+    std::vector<double> odd_vec = {1.0, 2.0, 3.0, 4.0, 5.0};
+    REQUIRE(vtr::median(odd_vec) == 3.0);
+    REQUIRE(vtr::median_presorted(odd_vec) == 3.0);
+
+    // Check the median of a vector with a median length.
+    std::vector<double> even_vec = {1.0, 2.0, 3.0, 4.0};
+    REQUIRE(vtr::median(even_vec) == 2.5);
+
+    // Check unsorted list gives correct median.
+    std::vector<double> unsorted_odd_vec = {2.0, 3.0, 1.0, 5.0, 4.0};
+    REQUIRE(vtr::median(unsorted_odd_vec) == 3.0);
+    std::vector<double> unsorted_even_vec = {2.0, 3.0, 1.0, 4.0};
+    REQUIRE(vtr::median(unsorted_even_vec) == 2.5);
+
+    // Check the median of a negative, odd-lengthed vector works.
+    std::vector<double> negative_odd_vec = {-1.0, -2.0, -3.0, -4.0, -5.0};
+    REQUIRE(vtr::median(negative_odd_vec) == -3.0);
+    REQUIRE(vtr::median_presorted(negative_odd_vec) == -3.0);
+
+    // Check the median of a negative, even-lengthed vector works.
+    std::vector<double> negative_even_vec = {-1.0, -2.0, -3.0, -4.0};
+    REQUIRE(vtr::median(negative_even_vec) == -2.5);
+    REQUIRE(vtr::median_presorted(negative_even_vec) == -2.5);
+
+    // Check the median of an fp vector with an odd length.
+    std::vector<float> fp_odd_vec = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+    REQUIRE(vtr::median(fp_odd_vec) == 3.0);
+    REQUIRE(vtr::median<float>(fp_odd_vec) == 3.0f);
+    REQUIRE(vtr::median_presorted<float>(fp_odd_vec) == 3.0f);
+
+    // Check the median of an fp vector with a median length.
+    std::vector<float> fp_even_vec = {1.0f, 2.0f, 3.0f, 4.0f};
+    REQUIRE(vtr::median(fp_even_vec) == 2.5);
+    REQUIRE(vtr::median<float>(fp_even_vec) == 2.5f);
+    REQUIRE(vtr::median_presorted<float>(fp_even_vec) == 2.5f);
+
+    // Check the median of an integral, odd-lengthed vecor.
+    std::vector<int> int_vec_odd = {1, 2, 3, 4, 5};
+    REQUIRE(vtr::median(int_vec_odd) == 3.0);
+    REQUIRE(vtr::median_presorted(int_vec_odd) == 3.0);
+
+    // Check the median of an integral, even-lengthed vecor.
+    std::vector<int> int_vec_even = {1, 2, 3, 4};
+    REQUIRE(vtr::median(int_vec_even) == 2.5);
+    REQUIRE(vtr::median_presorted(int_vec_even) == 2.5);
+
+    // Check that trying to get the median of an empty vector returns a NaN.
+    std::vector<double> empty_vec;
+    REQUIRE(std::isnan(vtr::median(empty_vec)));
+    REQUIRE(std::isnan(vtr::median_presorted(empty_vec)));
+}
diff --git a/vpr/src/place/delay_model/compute_delta_delays_utils.cpp b/vpr/src/place/delay_model/compute_delta_delays_utils.cpp
@@ -186,12 +186,12 @@ static vtr::NdMatrix<float, 4> compute_delta_delays(RouterDelayProfiler& route_p
     //   / = (high_x, low_y)
     //   \ = (low_x, high_y)
     //   + = device edge
-    const size_t mid_x = vtr::nint(device_width / 2);
-    const size_t mid_y = vtr::nint(device_height / 2);
+    const size_t mid_x = device_width / 2;
+    const size_t mid_y = device_height / 2;
     const size_t low_x = std::min(longest_length, mid_x);
     const size_t low_y = std::min(longest_length, mid_y);
     const size_t high_x = (longest_length <= device_width) ? std::max(device_width - longest_length, mid_x) : mid_x;
-    const size_t high_y = (longest_length <= device_height) ? std::max(device_width - longest_length, mid_y) : mid_y;
+    const size_t high_y = (longest_length <= device_height) ? std::max(device_height - longest_length, mid_y) : mid_y;
 
     vtr::NdMatrix<float, 4> delta_delays({num_layers, num_layers, device_width, device_height});
 
@@ -705,8 +705,8 @@ static float delay_reduce(std::vector<float>& delays, e_reducer reducer) {
         auto itr = std::max_element(delays.begin(), delays.end());
         delay = *itr;
     } else if (reducer == e_reducer::MEDIAN) {
-        std::stable_sort(delays.begin(), delays.end());
-        delay = vtr::median(delays.begin(), delays.end());
+        std::sort(delays.begin(), delays.end());
+        delay = vtr::median_presorted<float>(delays.begin(), delays.end());
     } else if (reducer == e_reducer::ARITHMEAN) {
         delay = vtr::arithmean(delays.begin(), delays.end());
     } else if (reducer == e_reducer::GEOMEAN) {
diff --git a/vpr/src/place/move_generators/simpleRL_move_generator.cpp b/vpr/src/place/move_generators/simpleRL_move_generator.cpp
@@ -227,9 +227,34 @@ t_propose_action EpsilonGreedyAgent::propose_action() {
     if (rng_.frand() < epsilon_) {
         /* Explore
          * With probability epsilon, choose randomly amongst all move types */
+
+        // Cummulative epsilon action probabilty stores a CDF for all available
+        // actions where each action has an equal probability to occur. Pick
+        // a random number between 0 and 1 and select the action in the CDF equal
+        // to or just less than the random number.
+        // For example, for four actions:
+        //        A     B    C     D
+        //      [0.25, 0.5, 0.75, 1.0]
+        //   Here, if the random number is 0.2, action A would be chosen.
+        //         if the random number is 0.5, action B would be chosen.
+        //         if the random number is 0.6, action C would be chosen.
+        //         if the random number is 1.0, action D would be chosen.
         float p = rng_.frand();
         auto itr = std::lower_bound(cumm_epsilon_action_prob_.begin(), cumm_epsilon_action_prob_.end(), p);
-        auto action_type_q_pos = itr - cumm_epsilon_action_prob_.begin();
+        size_t action_type_q_pos;
+        if (itr != cumm_epsilon_action_prob_.end()) {
+            action_type_q_pos = itr - cumm_epsilon_action_prob_.begin();
+        } else {
+            // Due to numerical precision (and dumb luck) its possible that the
+            // CDF does not fully add up to 1.0 (for example 0.9999) and the
+            // random number chosen is 1.0. In this case, no action will be
+            // chosen. In this case, just choose the last action.
+            // For example, for three actions:
+            //      [0.33, 0.66, 0.99]
+            //   Notice that the last action does not perfectly add up to 1.0. To
+            //   get around this, we just pretend that it rounded up to 1.0.
+            action_type_q_pos = num_available_actions_ - 1;
+        }
         //Mark the q_table location that agent used to update its value after processing the move outcome
         last_action_ = action_type_q_pos;
 
diff --git a/vpr/src/route/router_lookahead/router_lookahead_map_utils.cpp b/vpr/src/route/router_lookahead/router_lookahead_map_utils.cpp
@@ -14,6 +14,7 @@
 #include "globals.h"
 #include "physical_types_util.h"
 #include "vpr_context.h"
+#include "vpr_error.h"
 #include "vpr_utils.h"
 #include "vtr_math.h"
 #include "vtr_time.h"
@@ -263,8 +264,9 @@ Cost_Entry Expansion_Cost_Entry::get_median_entry() const {
      * with the largest number of entries */
 
     // This is code that needs to be revisited. For the time being, if the median entry
-    // method calculation is used an assertion is thrown.
-    VTR_ASSERT_MSG(false, "Get median entry calculation method is not implemented!");
+    // method calculation is used an error is thrown.
+    VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
+                    "Get median entry calculation method is not implemented!");
 
     int num_bins = 10;
 
