//===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // UNSUPPORTED: c++03, c++11, c++14, c++17 #include #include #include #include #include #include #include #include "benchmark/benchmark.h" #include "../../GenerateInput.h" int main(int argc, char** argv) { auto std_replace = [](auto first, auto last, auto old, auto new_) { return std::replace(first, last, old, new_); }; auto std_replace_if = [](auto first, auto last, auto old, auto new_) { auto pred = [&](auto element) { benchmark::DoNotOptimize(element); return element == old; }; return std::replace_if(first, last, pred, new_); }; auto ranges_replace_if = [](auto first, auto last, auto old, auto new_) { auto pred = [&](auto element) { benchmark::DoNotOptimize(element); return element == old; }; return std::ranges::replace_if(first, last, pred, new_); }; // Create a sequence of the form xxxxxxxxxxyyyyyyyyyy, replace // into zzzzzzzzzzzyyyyyyyyyy and then back. // // This measures the performance of replace() when replacing a large // contiguous sequence of equal values. { auto bm = [](std::string name, auto replace) { benchmark::RegisterBenchmark( name, [replace](auto& st) { std::size_t const size = st.range(0); using ValueType = typename Container::value_type; Container c; ValueType x = Generate::random(); ValueType y = random_different_from({x}); ValueType z = random_different_from({x, y}); std::fill_n(std::back_inserter(c), size / 2, x); std::fill_n(std::back_inserter(c), size / 2, y); for ([[maybe_unused]] auto _ : st) { benchmark::DoNotOptimize(c); benchmark::DoNotOptimize(x); benchmark::DoNotOptimize(z); replace(c.begin(), c.end(), x, z); benchmark::DoNotOptimize(c); std::swap(x, z); } }) ->Arg(32) ->Arg(50) // non power-of-two ->Arg(1024) ->Arg(8192); }; // {std,ranges}::replace bm.operator()>("std::replace(vector) (prefix)", std_replace); bm.operator()>("std::replace(deque) (prefix)", std_replace); bm.operator()>("std::replace(list) (prefix)", std_replace); bm.operator()>("rng::replace(vector) (prefix)", std::ranges::replace); bm.operator()>("rng::replace(deque) (prefix)", std::ranges::replace); bm.operator()>("rng::replace(list) (prefix)", std::ranges::replace); // {std,ranges}::replace_if bm.operator()>("std::replace_if(vector) (prefix)", std_replace_if); bm.operator()>("std::replace_if(deque) (prefix)", std_replace_if); bm.operator()>("std::replace_if(list) (prefix)", std_replace_if); bm.operator()>("rng::replace_if(vector) (prefix)", ranges_replace_if); bm.operator()>("rng::replace_if(deque) (prefix)", ranges_replace_if); bm.operator()>("rng::replace_if(list) (prefix)", ranges_replace_if); } // Sprinkle elements to replace inside the range, like xyxyxyxyxyxyxyxyxyxy. { auto bm = [](std::string name, auto replace) { benchmark::RegisterBenchmark( name, [replace](auto& st) { std::size_t const size = st.range(0); using ValueType = typename Container::value_type; Container c; ValueType x = Generate::random(); ValueType y = random_different_from({x}); ValueType z = random_different_from({x, y}); for (std::size_t i = 0; i != size; ++i) { c.push_back(i % 2 == 0 ? x : y); } for ([[maybe_unused]] auto _ : st) { benchmark::DoNotOptimize(c); benchmark::DoNotOptimize(x); benchmark::DoNotOptimize(z); replace(c.begin(), c.end(), x, z); benchmark::DoNotOptimize(c); std::swap(x, z); } }) ->Arg(32) ->Arg(50) // non power-of-two ->Arg(1024) ->Arg(8192); }; // {std,ranges}::replace bm.operator()>("std::replace(vector) (sprinkled)", std_replace); bm.operator()>("std::replace(deque) (sprinkled)", std_replace); bm.operator()>("std::replace(list) (sprinkled)", std_replace); bm.operator()>("rng::replace(vector) (sprinkled)", std::ranges::replace); bm.operator()>("rng::replace(deque) (sprinkled)", std::ranges::replace); bm.operator()>("rng::replace(list) (sprinkled)", std::ranges::replace); // {std,ranges}::replace_if bm.operator()>("std::replace_if(vector) (sprinkled)", std_replace_if); bm.operator()>("std::replace_if(deque) (sprinkled)", std_replace_if); bm.operator()>("std::replace_if(list) (sprinkled)", std_replace_if); bm.operator()>("rng::replace_if(vector) (sprinkled)", ranges_replace_if); bm.operator()>("rng::replace_if(deque) (sprinkled)", ranges_replace_if); bm.operator()>("rng::replace_if(list) (sprinkled)", ranges_replace_if); } benchmark::Initialize(&argc, argv); benchmark::RunSpecifiedBenchmarks(); benchmark::Shutdown(); return 0; }