Use 90% and 10% for symmetry

Author: ldionne

libcxx/test/benchmarks/algorithms/nonmodifying/find_first_of.bench.cpp

@@ -38,7 +38,7 @@ int main(int argc, char** argv) {
     });
   };
 
-  // Benchmark {std,ranges}::find_first_of where we have a hit at 25% of the haystack
+  // Benchmark {std,ranges}::find_first_of where we have a hit at 10% of the haystack
   // and at the end of the needle. This measures how quickly we're able to search inside
   // the needle.
   {
@@ -55,8 +55,8 @@ int main(int argc, char** argv) {
             Container needle(size, y);
             needle.back() = z; // hit at the very end of the needle
 
-            // put the needle at 25% of the haystack
-            *std::next(haystack.begin(), haystack.size() / 4) = z;
+            // put the needle at 10% of the haystack
+            *std::next(haystack.begin(), haystack.size() / 10) = z;
 
             for ([[maybe_unused]] auto _ : st) {
               benchmark::DoNotOptimize(haystack);
@@ -71,15 +71,15 @@ int main(int argc, char** argv) {
           ->Arg(8192);
     };
     // {std,ranges}::find_first_of(it1, it1, it2, it2)
-    bm.operator()<std::vector<int>>("std::find_first_of(vector<int>) (25% haystack, late needle)", std_find_first_of);
-    bm.operator()<std::deque<int>>("std::find_first_of(deque<int>) (25% haystack, late needle)", std_find_first_of);
-    bm.operator()<std::list<int>>("std::find_first_of(list<int>) (25% haystack, late needle)", std_find_first_of);
+    bm.operator()<std::vector<int>>("std::find_first_of(vector<int>) (10% haystack, late needle)", std_find_first_of);
+    bm.operator()<std::deque<int>>("std::find_first_of(deque<int>) (10% haystack, late needle)", std_find_first_of);
+    bm.operator()<std::list<int>>("std::find_first_of(list<int>) (10% haystack, late needle)", std_find_first_of);
     bm.operator()<std::vector<int>>(
-        "rng::find_first_of(vector<int>) (25% haystack, late needle)", std::ranges::find_first_of);
+        "rng::find_first_of(vector<int>) (10% haystack, late needle)", std::ranges::find_first_of);
     bm.operator()<std::deque<int>>(
-        "rng::find_first_of(deque<int>) (25% haystack, late needle)", std::ranges::find_first_of);
+        "rng::find_first_of(deque<int>) (10% haystack, late needle)", std::ranges::find_first_of);
     bm.operator()<std::list<int>>(
-        "rng::find_first_of(list<int>) (25% haystack, late needle)", std::ranges::find_first_of);
+        "rng::find_first_of(list<int>) (10% haystack, late needle)", std::ranges::find_first_of);
 
     // {std,ranges}::find_first_of(it1, it1, it2, it2, pred)
     bm.operator()<std::vector<int>>(
@@ -113,7 +113,7 @@ int main(int argc, char** argv) {
             *std::next(needle.begin(), needle.size() / 10) = z; // hit at 10% of the needle
 
             // put the needle at 90% of the haystack
-            *std::next(haystack.begin(), 9 * (haystack.size() / 10)) = z;
+            *std::next(haystack.begin(), (9 * haystack.size()) / 10) = z;
 
             for ([[maybe_unused]] auto _ : st) {
               benchmark::DoNotOptimize(haystack);

libcxx/test/benchmarks/algorithms/nonmodifying/find_last.bench.cpp

@@ -34,7 +34,7 @@ int main(int argc, char** argv) {
   };
 
   // Benchmark ranges::{find_last,find_last_if,find_last_if_not} where the last element
-  // is found 25% into the sequence
+  // is found 10% into the sequence
   {
     auto bm = []<class Container>(std::string name, auto find_last) {
       benchmark::RegisterBenchmark(
@@ -46,8 +46,8 @@ int main(int argc, char** argv) {
             ValueType y            = random_different_from({x});
             Container c(size, x);
 
-            // put the element we're searching for at 25% of the sequence
-            *std::next(c.begin(), size / 4) = y;
+            // put the element we're searching for at 10% of the sequence
+            *std::next(c.begin(), size / 10) = y;
 
             for ([[maybe_unused]] auto _ : st) {
               benchmark::DoNotOptimize(c);
@@ -64,26 +64,26 @@ int main(int argc, char** argv) {
     };
 
     // find_last
-    bm.operator()<std::vector<char>>("rng::find_last(vector<char>) (bail 25%)", std::ranges::find_last);
-    bm.operator()<std::vector<int>>("rng::find_last(vector<int>) (bail 25%)", std::ranges::find_last);
-    bm.operator()<std::deque<int>>("rng::find_last(deque<int>) (bail 25%)", std::ranges::find_last);
-    bm.operator()<std::list<int>>("rng::find_last(list<int>) (bail 25%)", std::ranges::find_last);
-    bm.operator()<std::forward_list<int>>("rng::find_last(forward_list<int>) (bail 25%)", std::ranges::find_last);
+    bm.operator()<std::vector<char>>("rng::find_last(vector<char>) (bail 10%)", std::ranges::find_last);
+    bm.operator()<std::vector<int>>("rng::find_last(vector<int>) (bail 10%)", std::ranges::find_last);
+    bm.operator()<std::deque<int>>("rng::find_last(deque<int>) (bail 10%)", std::ranges::find_last);
+    bm.operator()<std::list<int>>("rng::find_last(list<int>) (bail 10%)", std::ranges::find_last);
+    bm.operator()<std::forward_list<int>>("rng::find_last(forward_list<int>) (bail 10%)", std::ranges::find_last);
 
     // find_last_if
-    bm.operator()<std::vector<char>>("rng::find_last_if(vector<char>) (bail 25%)", ranges_find_last_if);
-    bm.operator()<std::vector<int>>("rng::find_last_if(vector<int>) (bail 25%)", ranges_find_last_if);
-    bm.operator()<std::deque<int>>("rng::find_last_if(deque<int>) (bail 25%)", ranges_find_last_if);
-    bm.operator()<std::list<int>>("rng::find_last_if(list<int>) (bail 25%)", ranges_find_last_if);
-    bm.operator()<std::forward_list<int>>("rng::find_last_if(forward_list<int>) (bail 25%)", ranges_find_last_if);
+    bm.operator()<std::vector<char>>("rng::find_last_if(vector<char>) (bail 10%)", ranges_find_last_if);
+    bm.operator()<std::vector<int>>("rng::find_last_if(vector<int>) (bail 10%)", ranges_find_last_if);
+    bm.operator()<std::deque<int>>("rng::find_last_if(deque<int>) (bail 10%)", ranges_find_last_if);
+    bm.operator()<std::list<int>>("rng::find_last_if(list<int>) (bail 10%)", ranges_find_last_if);
+    bm.operator()<std::forward_list<int>>("rng::find_last_if(forward_list<int>) (bail 10%)", ranges_find_last_if);
 
     // find_last_if_not
-    bm.operator()<std::vector<char>>("rng::find_last_if_not(vector<char>) (bail 25%)", ranges_find_last_if_not);
-    bm.operator()<std::vector<int>>("rng::find_last_if_not(vector<int>) (bail 25%)", ranges_find_last_if_not);
-    bm.operator()<std::deque<int>>("rng::find_last_if_not(deque<int>) (bail 25%)", ranges_find_last_if_not);
-    bm.operator()<std::list<int>>("rng::find_last_if_not(list<int>) (bail 25%)", ranges_find_last_if_not);
+    bm.operator()<std::vector<char>>("rng::find_last_if_not(vector<char>) (bail 10%)", ranges_find_last_if_not);
+    bm.operator()<std::vector<int>>("rng::find_last_if_not(vector<int>) (bail 10%)", ranges_find_last_if_not);
+    bm.operator()<std::deque<int>>("rng::find_last_if_not(deque<int>) (bail 10%)", ranges_find_last_if_not);
+    bm.operator()<std::list<int>>("rng::find_last_if_not(list<int>) (bail 10%)", ranges_find_last_if_not);
     bm.operator()<std::forward_list<int>>(
-        "rng::find_last_if_not(forward_list<int>) (bail 25%)", ranges_find_last_if_not);
+        "rng::find_last_if_not(forward_list<int>) (bail 10%)", ranges_find_last_if_not);
   }
 
   // Benchmark ranges::{find_last,find_last_if,find_last_if_not} where the last element
@@ -100,7 +100,7 @@ int main(int argc, char** argv) {
             Container c(size, x);
 
             // put the element we're searching for at 90% of the sequence
-            *std::next(c.begin(), 9 * (size / 10)) = y;
+            *std::next(c.begin(), (9 * size) / 10) = y;
 
             for ([[maybe_unused]] auto _ : st) {
               benchmark::DoNotOptimize(c);