[LibVTR][Math] Handled Pre-sorting Median Calculation

Author: AlexandreSinger

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<float>(C_total[RRIndexedDataId(cost_index)]);
-            float Rnode = vtr::median<float>(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);

libs/libvtrutil/src/vtr_math.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <iterator>
 #include <map>
 #include <vector>
@@ -36,8 +37,10 @@ T safe_ratio(T numerator, T denominator) {
 ///@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(InputIterator first, InputIterator last) {
+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.
@@ -66,10 +69,22 @@ ResultTy median(InputIterator first, InputIterator last) {
     }
 }
 
-///@brief Returns the median of a whole container
+///@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) {
-    return median<ResultTy>(std::begin(c), std::end(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));
 }
 
 /**
@@ -84,7 +99,7 @@ ResultTy 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) {
@@ -101,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)
 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) {
@@ -124,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));
 }
 

libs/libvtrutil/test/test_math.cpp

@@ -1,5 +1,6 @@
 #include <cmath>
 #include <limits>
+#include <vector>
 
 #include "catch2/catch_test_macros.hpp"
 #include "catch2/catch_approx.hpp"
@@ -62,46 +63,62 @@ 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)));
 }

vpr/src/place/delay_model/compute_delta_delays_utils.cpp

@@ -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<float>(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) {