Merge branch 'dev' into main

Author: danlark1

benches/benchmark_select.cpp

@@ -18,44 +18,31 @@
 namespace miniselect {
 namespace {
 
-static constexpr size_t kSize = 1000 * 1000 * 10;
+static constexpr size_t kSize = 65536;
 
 template <class DataGen, class Impl>
 static void BM_sel(benchmark::State& state) {
   auto vec = DataGen::Gen(kSize);
   const size_t arg = state.range(0);
   size_t cnt = 0;
-  size_t cmp = 0;
+  size_t access_count = 0;
+  size_t comparison_count = 0;
+  miniselect::datagens::CountingIterator begin_v(&vec, 0, &access_count);
+  miniselect::datagens::CountingIterator end_v(&vec, vec.size(), &access_count);
   for (auto _ : state) {
-    Impl::Select(vec.begin(), vec.begin() + arg, vec.end(),
-                 [&cmp](const auto& left, const auto& right) {
-                   cmp++;
+    Impl::Select(begin_v, begin_v + arg, end_v,
+                 [&comparison_count](const auto& left, const auto& right) {
+                   comparison_count++;
                    return left < right;
                  });
     ++cnt;
     benchmark::DoNotOptimize(vec[arg]);
   }
-  state.counters["Comparisons"] = 1.0 * cmp / cnt;
-}
-
-template <class DataGen, class Impl>
-static void BM_sel_accesses(benchmark::State& state) {
-  auto vec = DataGen::Gen(kSize);
-  const size_t arg = state.range(0);
-  size_t cnt = 0;
-  size_t cmp = 0;
-  miniselect::datagens::CountingIterator begin_v(&vec, 0, &cmp);
-  miniselect::datagens::CountingIterator end_v(&vec, vec.size(), &cmp);
-  for (auto _ : state) {
-    Impl::Select(begin_v, begin_v + arg, end_v);
-    ++cnt;
-    benchmark::DoNotOptimize(vec[arg]);
-  }
-  state.counters["Array Accesses"] = 1.0 * cmp / cnt;
+  state.counters["Array Accesses"] = 1.0 * access_count / cnt;
+  state.counters["Comparisons"] = 1.0 * comparison_count / cnt;
 }
 
 BENCH(BM_sel);
-BENCH(BM_sel_accesses);
 
 }  // namespace
 }  // namespace miniselect

benches/benchmark_sort.cpp

@@ -25,37 +25,24 @@ static void BM_sort(benchmark::State& state) {
   auto vec = DataGen::Gen(kSize);
   const size_t arg = state.range(0);
   size_t cnt = 0;
-  size_t cmp = 0;
+  size_t access_count = 0;
+  size_t comparison_count = 0;
+  miniselect::datagens::CountingIterator begin_v(&vec, 0, &access_count);
+  miniselect::datagens::CountingIterator end_v(&vec, vec.size(), &access_count);
   for (auto _ : state) {
-    Impl::Sort(vec.begin(), vec.begin() + arg, vec.end(),
-               [&cmp](const auto& left, const auto& right) {
-                 cmp++;
+    Impl::Sort(begin_v, begin_v + arg, end_v,
+               [&comparison_count](const auto& left, const auto& right) {
+                 comparison_count++;
                  return left < right;
                });
     ++cnt;
     benchmark::DoNotOptimize(vec[arg]);
   }
-  state.counters["Comparisons"] = 1.0 * cmp / cnt;
-}
-
-template <class DataGen, class Impl>
-static void BM_sort_accesses(benchmark::State& state) {
-  auto vec = DataGen::Gen(kSize);
-  const size_t arg = state.range(0);
-  size_t cnt = 0;
-  size_t cmp = 0;
-  miniselect::datagens::CountingIterator begin_v(&vec, 0, &cmp);
-  miniselect::datagens::CountingIterator end_v(&vec, vec.size(), &cmp);
-  for (auto _ : state) {
-    Impl::Sort(begin_v, begin_v + arg, end_v);
-    ++cnt;
-    benchmark::DoNotOptimize(vec[arg]);
-  }
-  state.counters["Array Accesses"] = 1.0 * cmp / cnt;
+  state.counters["Array Accesses"] = 1.0 * access_count / cnt;
+  state.counters["Comparisons"] = 1.0 * comparison_count / cnt;
 }
 
 BENCH(BM_sort);
-BENCH(BM_sort_accesses);
 
 }  // namespace
 }  // namespace miniselect

include/miniselect/floyd_rivest_select.h

@@ -16,34 +16,43 @@
 namespace miniselect {
 namespace floyd_rivest_detail {
 
+enum floyd_rivest_constants {
+  kQCap = 600,
+};
+
 template <class Compare>
 struct CompareRefType {
   // Pass the comparator by lvalue reference. Or in debug mode, using a
   // debugging wrapper that stores a reference.
   using type = typename std::add_lvalue_reference<Compare>::type;
 };
 
-template <class Iter, class Compare, class Diff>
-inline void floyd_rivest_select_loop(Iter begin, Diff left, Diff right, Diff k,
-                                     Compare comp) {
+template <class Iter, class Compare,
+          class DiffType = typename std::iterator_traits<Iter>::difference_type>
+inline void floyd_rivest_select_loop(Iter begin, DiffType left, DiffType right,
+                                     DiffType k, Compare comp) {
   while (right > left) {
-    Diff size = right - left;
-    if (size > 600) {
-      Diff n = right - left + 1;
-      Diff i = k - left + 1;
+    DiffType size = right - left;
+    if (size > floyd_rivest_constants::kQCap) {
+      DiffType n = right - left + 1;
+      DiffType i = k - left + 1;
+
       double z = log(n);
       double s = 0.5 * exp(2 * z / 3);
       double sd = 0.5 * sqrt(z * s * (n - s) / n);
       if (i < n / 2) {
         sd *= -1.0;
       }
-      Diff newLeft = std::max(left, (Diff)(k - i * s / n + sd));
-      Diff newRight = std::min(right, (Diff)(k + (n - i) * s / n + sd));
-      floyd_rivest_select_loop<Iter, Compare, Diff>(begin, newLeft, newRight, k,
-                                                    comp);
+      DiffType newLeft =
+          std::max(left, static_cast<DiffType>(k - i * s / n + sd));
+      DiffType newRight =
+          std::min(right, static_cast<DiffType>(k + (n - i) * s / n + sd));
+      floyd_rivest_select_loop<Iter, Compare, DiffType>(begin, newLeft,
+                                                        newRight, k, comp);
     }
-    Diff i = left;
-    Diff j = right;
+    DiffType i = left;
+    DiffType j = right;
+
     std::swap(begin[left], begin[k]);
     const bool to_swap = comp(begin[left], begin[right]);
     if (to_swap) {
@@ -87,10 +96,9 @@ inline void floyd_rivest_partial_sort(Iter begin, Iter mid, Iter end,
   if (begin == end) return;
   if (begin == mid) return;
   using CompType = typename floyd_rivest_detail::CompareRefType<Compare>::type;
-
-  floyd_rivest_detail::floyd_rivest_select_loop<
-      Iter, CompType, typename std::iterator_traits<Iter>::difference_type>(
-      begin, 0, end - begin - 1, mid - begin - 1, comp);
+  using DiffType = typename std::iterator_traits<Iter>::difference_type;
+  floyd_rivest_detail::floyd_rivest_select_loop<Iter, CompType>(
+      begin, DiffType{0}, end - begin - 1, mid - begin - 1, comp);
   // std::sort proved to be better than other sorts because of pivoting.
   std::sort<Iter, CompType>(begin, mid, comp);
 }
@@ -105,10 +113,9 @@ template <class Iter, class Compare>
 inline void floyd_rivest_select(Iter begin, Iter mid, Iter end, Compare comp) {
   if (mid == end) return;
   using CompType = typename floyd_rivest_detail::CompareRefType<Compare>::type;
-
-  floyd_rivest_detail::floyd_rivest_select_loop<
-      Iter, CompType, typename std::iterator_traits<Iter>::difference_type>(
-      begin, 0, end - begin - 1, mid - begin, comp);
+  using DiffType = typename std::iterator_traits<Iter>::difference_type;
+  floyd_rivest_detail::floyd_rivest_select_loop<Iter, CompType>(
+      begin, DiffType{0}, end - begin - 1, mid - begin, comp);
 }
 
 template <class Iter>

include/miniselect/median_of_3_random.h

@@ -17,17 +17,17 @@ namespace miniselect {
 namespace median_of_3_random_detail {
 
 template <class Iter, class Compare>
-static inline Iter partition(Iter r, Iter end, Compare&& comp) {
-  typedef typename std::iterator_traits<Iter>::difference_type T;
-  const T len = end - r;
+inline Iter partition(Iter r, Iter end, Compare&& comp) {
+  using DiffType = typename std::iterator_traits<Iter>::difference_type;
+  const DiffType len = end - r;
   assert(len >= 3);
   static std::mt19937_64 gen(1);
-  std::uniform_int_distribution<T> dis(0, len - 1);
-  T x = dis(gen);
-  T y = dis(gen);
-  T z = dis(gen);
-  return median_common_detail::pivotPartition(
-      r, median_common_detail::medianIndex(r, x, y, z, comp), len, comp);
+  std::uniform_int_distribution<DiffType> dis(0, len - 1);
+  DiffType x = dis(gen);
+  DiffType y = dis(gen);
+  DiffType z = dis(gen);
+  return median_common_detail::pivot_partition(
+      r, median_common_detail::median_index(r, x, y, z, comp), len, comp);
 }
 
 }  // namespace median_of_3_random_detail

include/miniselect/median_of_medians.h

@@ -16,20 +16,21 @@ namespace miniselect {
 namespace median_of_medians_detail {
 
 template <class Iter, class Compare>
-static inline Iter partition(Iter r, Iter end, Compare&& comp) {
+inline Iter partition(Iter r, Iter end, Compare&& comp) {
   using CompType = typename median_common_detail::CompareRefType<Compare>::type;
-  const size_t len = end - r;
+  using DiffType = typename std::iterator_traits<Iter>::difference_type;
+  const DiffType len = end - r;
   if (len < 5) {
-    return median_common_detail::pivotPartition(r, len / 2, len, comp);
+    return median_common_detail::pivot_partition(r, len / 2, len, comp);
   }
-  size_t j = 0;
-  for (size_t i = 4; i < len; i += 5, ++j) {
+  DiffType j = 0;
+  for (DiffType i = 4; i < len; i += 5, ++j) {
     median_common_detail::partition5(r, i - 4, i - 3, i, i - 2, i - 1, comp);
     std::swap(r[i], r[j]);
   }
   median_common_detail::quickselect<Iter, CompType, &partition>(r, r + j / 2,
                                                                 r + j, comp);
-  return median_common_detail::pivotPartition(r, j / 2, len, comp);
+  return median_common_detail::pivot_partition(r, j / 2, len, comp);
 }
 
 }  // namespace median_of_medians_detail
@@ -47,7 +48,7 @@ inline void median_of_medians_select(Iter begin, Iter mid, Iter end,
 
 template <class Iter>
 inline void median_of_medians_select(Iter begin, Iter mid, Iter end) {
-  typedef typename std::iterator_traits<Iter>::value_type T;
+  using T = typename std::iterator_traits<Iter>::value_type;
   median_of_medians_select(begin, mid, end, std::less<T>());
 }
 
@@ -64,7 +65,7 @@ inline void median_of_medians_partial_sort(Iter begin, Iter mid, Iter end,
 
 template <class Iter>
 inline void median_of_medians_partial_sort(Iter begin, Iter mid, Iter end) {
-  typedef typename std::iterator_traits<Iter>::value_type T;
+  using T = typename std::iterator_traits<Iter>::value_type;
   median_of_medians_partial_sort(begin, mid, end, std::less<T>());
 }