235 lines · cpp
1//===----------------------------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9// UNSUPPORTED: c++03, c++11, c++14, c++1710 11#include <algorithm>12#include <deque>13 14#include "benchmark/benchmark.h"15 16namespace {17void run_sizes(auto benchmark) {18 benchmark->Arg(0)19 ->Arg(1)20 ->Arg(2)21 ->Arg(64)22 ->Arg(512)23 ->Arg(1024)24 ->Arg(4000)25 ->Arg(4096)26 ->Arg(5500)27 ->Arg(64000)28 ->Arg(65536)29 ->Arg(70000);30}31 32template <class FromContainer, class ToContainer, class Func>33void benchmark_containers(benchmark::State& state, FromContainer& d, ToContainer& v, Func&& func) {34 for (auto _ : state) {35 benchmark::DoNotOptimize(v);36 benchmark::DoNotOptimize(d);37 func(d.begin(), d.end(), v.begin());38 }39}40 41template <class Func>42void benchmark_deque_vector(benchmark::State& state, Func&& func) {43 auto size = state.range(0);44 std::deque<int> d;45 d.resize(size);46 std::ranges::fill(d, 10);47 std::vector<int> v;48 v.resize(size);49 benchmark_containers(state, d, v, func);50}51 52template <class Func>53void benchmark_deque_deque(benchmark::State& state, Func&& func) {54 auto size = state.range(0);55 std::deque<int> d;56 d.resize(size);57 std::ranges::fill(d, 10);58 std::deque<int> v;59 v.resize(size);60 benchmark_containers(state, d, v, func);61}62 63template <class Func>64void benchmark_vector_deque(benchmark::State& state, Func&& func) {65 auto size = state.range(0);66 std::vector<int> d;67 d.resize(size);68 std::ranges::fill(d, 10);69 std::deque<int> v;70 v.resize(size);71 benchmark_containers(state, d, v, func);72}73 74template <class FromContainer, class ToContainer, class Func>75void benchmark_containers_backward(benchmark::State& state, FromContainer& d, ToContainer& v, Func&& func) {76 for (auto _ : state) {77 benchmark::DoNotOptimize(v);78 benchmark::DoNotOptimize(d);79 func(d.begin(), d.end(), v.end());80 }81}82 83template <class Func>84void benchmark_deque_vector_backward(benchmark::State& state, Func&& func) {85 auto size = state.range(0);86 std::deque<int> d;87 d.resize(size);88 std::ranges::fill(d, 10);89 std::vector<int> v;90 v.resize(size);91 benchmark_containers_backward(state, d, v, func);92}93 94template <class Func>95void benchmark_deque_deque_backward(benchmark::State& state, Func&& func) {96 auto size = state.range(0);97 std::deque<int> d;98 d.resize(size);99 std::ranges::fill(d, 10);100 std::deque<int> v;101 v.resize(size);102 benchmark_containers_backward(state, d, v, func);103}104 105template <class Func>106void benchmark_vector_deque_backward(benchmark::State& state, Func&& func) {107 auto size = state.range(0);108 std::vector<int> d;109 d.resize(size);110 std::ranges::fill(d, 10);111 std::deque<int> v;112 v.resize(size);113 benchmark_containers_backward(state, d, v, func);114}115 116struct CopyFunctor {117 template <class... Args>118 auto operator()(Args... args) const {119 std::copy(std::forward<Args>(args)...);120 }121} copy;122 123struct MoveFunctor {124 template <class... Args>125 auto operator()(Args... args) const {126 std::move(std::forward<Args>(args)...);127 }128} move;129 130struct CopyBackwardFunctor {131 template <class... Args>132 auto operator()(Args... args) const {133 std::copy_backward(std::forward<Args>(args)...);134 }135} copy_backward;136 137struct MoveBackwardFunctor {138 template <class... Args>139 auto operator()(Args... args) const {140 std::move_backward(std::forward<Args>(args)...);141 }142} move_backward;143 144// copy145void BM_deque_vector_copy(benchmark::State& state) { benchmark_deque_vector(state, copy); }146BENCHMARK(BM_deque_vector_copy)->Apply(run_sizes);147 148void BM_deque_vector_ranges_copy(benchmark::State& state) { benchmark_deque_vector(state, std::ranges::copy); }149BENCHMARK(BM_deque_vector_ranges_copy)->Apply(run_sizes);150 151void BM_deque_deque_copy(benchmark::State& state) { benchmark_deque_deque(state, copy); }152BENCHMARK(BM_deque_deque_copy)->Apply(run_sizes);153 154void BM_deque_deque_ranges_copy(benchmark::State& state) { benchmark_deque_deque(state, std::ranges::copy); }155BENCHMARK(BM_deque_deque_ranges_copy)->Apply(run_sizes);156 157void BM_vector_deque_copy(benchmark::State& state) { benchmark_vector_deque(state, copy); }158BENCHMARK(BM_vector_deque_copy)->Apply(run_sizes);159 160void BM_vector_deque_ranges_copy(benchmark::State& state) { benchmark_vector_deque(state, std::ranges::copy); }161BENCHMARK(BM_vector_deque_ranges_copy)->Apply(run_sizes);162 163// move164void BM_deque_vector_move(benchmark::State& state) { benchmark_deque_vector(state, move); }165BENCHMARK(BM_deque_vector_move)->Apply(run_sizes);166 167void BM_deque_vector_ranges_move(benchmark::State& state) { benchmark_deque_vector(state, std::ranges::move); }168BENCHMARK(BM_deque_vector_ranges_move)->Apply(run_sizes);169 170void BM_deque_deque_move(benchmark::State& state) { benchmark_deque_deque(state, move); }171BENCHMARK(BM_deque_deque_move)->Apply(run_sizes);172 173void BM_deque_deque_ranges_move(benchmark::State& state) { benchmark_deque_deque(state, std::ranges::move); }174BENCHMARK(BM_deque_deque_ranges_move)->Apply(run_sizes);175 176void BM_vector_deque_move(benchmark::State& state) { benchmark_vector_deque(state, move); }177BENCHMARK(BM_vector_deque_move)->Apply(run_sizes);178 179void BM_vector_deque_ranges_move(benchmark::State& state) { benchmark_vector_deque(state, std::ranges::move); }180BENCHMARK(BM_vector_deque_ranges_move)->Apply(run_sizes);181 182// copy_backward183void BM_deque_vector_copy_backward(benchmark::State& state) { benchmark_deque_vector_backward(state, copy_backward); }184BENCHMARK(BM_deque_vector_copy_backward)->Apply(run_sizes);185 186void BM_deque_vector_ranges_copy_backward(benchmark::State& state) {187 benchmark_deque_vector_backward(state, std::ranges::copy_backward);188}189BENCHMARK(BM_deque_vector_ranges_copy_backward)->Apply(run_sizes);190 191void BM_deque_deque_copy_backward(benchmark::State& state) { benchmark_deque_deque_backward(state, copy_backward); }192BENCHMARK(BM_deque_deque_copy_backward)->Apply(run_sizes);193 194void BM_deque_deque_ranges_copy_backward(benchmark::State& state) {195 benchmark_deque_deque_backward(state, std::ranges::copy_backward);196}197BENCHMARK(BM_deque_deque_ranges_copy_backward)->Apply(run_sizes);198 199void BM_vector_deque_copy_backward(benchmark::State& state) { benchmark_vector_deque_backward(state, copy_backward); }200BENCHMARK(BM_vector_deque_copy_backward)->Apply(run_sizes);201 202void BM_vector_deque_ranges_copy_backward(benchmark::State& state) {203 benchmark_vector_deque_backward(state, std::ranges::copy_backward);204}205BENCHMARK(BM_vector_deque_ranges_copy_backward)->Apply(run_sizes);206 207// move_backward208void BM_deque_vector_move_backward(benchmark::State& state) { benchmark_deque_vector_backward(state, move_backward); }209BENCHMARK(BM_deque_vector_move_backward)->Apply(run_sizes);210 211void BM_deque_vector_ranges_move_backward(benchmark::State& state) {212 benchmark_deque_vector_backward(state, std::ranges::move_backward);213}214BENCHMARK(BM_deque_vector_ranges_move_backward)->Apply(run_sizes);215 216void BM_deque_deque_move_backward(benchmark::State& state) { benchmark_deque_deque_backward(state, move_backward); }217BENCHMARK(BM_deque_deque_move_backward)->Apply(run_sizes);218 219void BM_deque_deque_ranges_move_backward(benchmark::State& state) {220 benchmark_deque_deque_backward(state, std::ranges::move_backward);221}222BENCHMARK(BM_deque_deque_ranges_move_backward)->Apply(run_sizes);223 224void BM_vector_deque_move_backward(benchmark::State& state) { benchmark_vector_deque_backward(state, move_backward); }225BENCHMARK(BM_vector_deque_move_backward)->Apply(run_sizes);226 227void BM_vector_deque_ranges_move_backward(benchmark::State& state) {228 benchmark_vector_deque_backward(state, std::ranges::move_backward);229}230BENCHMARK(BM_vector_deque_ranges_move_backward)->Apply(run_sizes);231 232} // namespace233 234BENCHMARK_MAIN();235