[libc++][NFC] Apply clang-format on large parts of the code base

[ldionne]

Summary

This commit does a pass of clang-format over files in libc++ that
don't require major changes to conform to our style guide, or for
which we're not overly concerned about conflicting with in-flight
patches or hindering the git blame.

This roughly covers:

• benchmarks
• range algorithms
• concepts
• type traits

I did a manual verification of all the changes, and in particular I
applied clang-format on/off annotations in a few places where the
result was less readable after than before. This was not necessary
in a lot of places, however I did find that clang-format had pretty
bad taste when it comes to formatting concepts.

[philnik]

libcxx/benchmarks/Utilities.h

30

libcxx/benchmarks/allocation.bench.cpp

20

Maybe as a quick follow-up?

[Mordante]

LGTM! After committing can you do a follow-up commit, adding this commit to .git-blame-ignore-revs?

I noticed in the past we have quite some headers in include that are "almost-formatted" (diff < 25-ish lines) would it make sense to do these too?

In general I wonder whether we should be slightly more aggressive in removing this tech debt. I know we want to avoid disrupting active patches, which I think is great. OTOH we have quite some inactive places were we could do
_VSTD -> std
typedef -> using
_LIBCPP_INLINE_VISIBILITY -> _LIBCPP_HIDE_FROM_ABI

This is something we need to point out in reviews quite often or get questions about it.

We still have a lot of old patches, but I think we need quite some effort to rebase them anyway; and I'm not even sure whether to original authors are intending to pursue these patches.

[ldionne]

@Mordante I will expand the scope of this patch to touch more headers. I won't do everything because I want to avoid touching active areas and manually auditing everything is time consuming, but I've got a patch that applies clang-format to a couple hundred files.

libcxx/benchmarks/allocation.bench.cpp

20

Will do in a separate patch.

[ldionne]

Expand scope.

[ldionne]

libcxx/include/__concepts/copyable.h

27 ↗

(On Diff #532210)

For some concepts where I judged that alignment was really helping readability, I added on/off annotations. In other places I didn't because I felt like readability was less affected, but this is arguably a judgement call.

[Mordante]

In D153140#4428753, @ldionne wrote:

@Mordante I will expand the scope of this patch to touch more headers. I won't do everything because I want to avoid touching active areas and manually auditing everything is time consuming, but I've got a patch that applies clang-format to a couple hundred files.

Thanks! I looked over the files and didn't spot bad formatting.

libcxx/include/__type_traits/invoke.h

355 ↗

(On Diff #532210)

Good old C++03 ;-)

libcxx/include/__type_traits/is_scalar.h

21 ↗

(On Diff #532210)

Odd it changed it here, but I don't see issues with the change.

[ldionne]

libcxx/include/__type_traits/invoke.h

355 ↗

(On Diff #532210)

Yeah, that's annoying! Is this a request to change this instance and other ones? I'm not sure it's possible because clang-format will try to enforce that (unfortunate) whitespace.

libcxx/include/__type_traits/is_scalar.h

21 ↗

(On Diff #532210)

I played around a bit and it looks like clang-format thinks that this file is objective-C because of the block syntax, and our .clang-format file doesn't apply to Objc. I'd like to address that in a separate patch.

[ldionne]

Rebase onto CI fixes

[Mordante]

libcxx/include/__type_traits/invoke.h

355 ↗

(On Diff #532210)

Fixing it will refrain clang-format from touching it. Feel free to ignore it.

libcxx/include/__type_traits/is_scalar.h

21 ↗

(On Diff #532210)

A cool you found a cause. I was quite baffled by it. I initially was concerned there was an issue with the code.

[philnik]

libcxx/include/__concepts/copyable.h

27 ↗

(On Diff #532210)

I'm fine with having a few // clang-format on/off in the code. clang-format is for the 99% where there isn't a readability problem and we just need some formatting decision.

libcxx/include/__type_traits/decay.h

49 ↗

(On Diff #532253)

libcxx/include/__type_traits/invoke.h

355 ↗

(On Diff #532210)

Yeah, this is the SpacesInAngles: Leave. It won't remove any whitespace tokens, but also won't add any.

libcxx/include/__type_traits/is_convertible.h

52 ↗

(On Diff #532253)

In this case I don't get why you didn't just clang-format it. Also for the similar ones below.

[ldionne]

Apply comments.

libcxx/include/__type_traits/invoke.h

355 ↗

(On Diff #532210)

Ah, I understand now. Ok, I fixed it.

libcxx/include/__type_traits/is_convertible.h

52 ↗

(On Diff #532253)

It's really helpful to align these definitions:

template <class _Tp> struct __is_array_function_or_void<_Tp, true, false, false> { enum { value = 1 }; };
template <class _Tp> struct __is_array_function_or_void<_Tp, false, true, false> { enum { value = 2 }; };
template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> { enum { value = 3 }; };

Otherwise, which specialization handles which combination of is_array/is_function/is_void isn't nearly as clear. A similar reasoning applies in other places.

I've left things as-is.

[philnik]

libcxx/include/__type_traits/is_convertible.h

52 ↗

(On Diff #532253)

template <class _Tp>
struct __is_array_function_or_void<_Tp, true, false, false> {
  enum { value = 1 };
};
template <class _Tp>
struct __is_array_function_or_void<_Tp, false, true, false> {
  enum { value = 2 };
};
template <class _Tp>
struct __is_array_function_or_void<_Tp, false, false, true> {
  enum { value = 3 };
};

is the formatted version, which looks just as readable to me. the true, false, false etc. are still aligned.

[ldionne]

libcxx/include/__type_traits/is_convertible.h

52 ↗

(On Diff #532253)

I agree that when looked at in isolation, both are comparable in readability. But when they appear in the file as a whole, it becomes a lot less clear that these declarations are related when each of them uses 4 lines than when they are each a one-liner. I'll land the patch as-is and we can discuss this more and change it in a follow-up patch, but I'd like to avoid merge conflicts by delaying this based on something that's easy to change.

libcxx/benchmarks/CartesianBenchmarks.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <vector>
 
 #include "benchmark/benchmark.h"
 #include "test_macros.h"
 
 namespace internal {
 
 template <class D, class E, size_t I>
 struct EnumValue : std::integral_constant<E, static_cast<E>(I)> {
   static std::string name() { return std::string("_") + D::Names[I]; }
 };
 
-template <class D, class E, size_t ...Idxs>
+template <class D, class E, size_t... Idxs>
 constexpr auto makeEnumValueTuple(std::index_sequence<Idxs...>) {
   return std::make_tuple(EnumValue<D, E, Idxs>{}...);
 }
 
 template <class B>
 static auto skip(const B& Bench, int) -> decltype(Bench.skip()) {
   return Bench.skip();
 }
 template <class B>
 static auto skip(const B& Bench, char) {
   return false;
 }
 
 template <class B, class Args, size_t... Is>
 void makeBenchmarkFromValuesImpl(const Args& A, std::index_sequence<Is...>) {
   for (auto& V : A) {
     B Bench{std::get<Is>(V)...};
     if (!internal::skip(Bench, 0)) {
-      benchmark::RegisterBenchmark(Bench.name().c_str(),
-                                   [=](benchmark::State& S) { Bench.run(S); });
+      benchmark::RegisterBenchmark(Bench.name().c_str(), [=](benchmark::State& S) { Bench.run(S); });
     }
   }
 }
 
 template <class B, class... Args>
 void makeBenchmarkFromValues(const std::vector<std::tuple<Args...> >& A) {
   makeBenchmarkFromValuesImpl<B>(A, std::index_sequence_for<Args...>());
 }
 
 template <template <class...> class B, class Args, class... U>
 void makeBenchmarkImpl(const Args& A, std::tuple<U...> t) {
   makeBenchmarkFromValues<B<U...> >(A);
 }
 
-template <template <class...> class B, class Args, class... U,
-          class... T, class... Tuples>
-void makeBenchmarkImpl(const Args& A, std::tuple<U...>, std::tuple<T...>,
-                       Tuples... rest) {
+template <template <class...> class B, class Args, class... U, class... T, class... Tuples>
+void makeBenchmarkImpl(const Args& A, std::tuple<U...>, std::tuple<T...>, Tuples... rest) {
   (internal::makeBenchmarkImpl<B>(A, std::tuple<U..., T>(), rest...), ...);
 }
 
 template <class R, class T>
 void allValueCombinations(R& Result, const T& Final) {
   return Result.push_back(Final);
 }
 
 template <class R, class T, class V, class... Vs>
-void allValueCombinations(R& Result, const T& Prev, const V& Value,
-                          const Vs&... Values) {
+void allValueCombinations(R& Result, const T& Prev, const V& Value, const Vs&... Values) {
   for (const auto& E : Value) {
-    allValueCombinations(Result, std::tuple_cat(Prev, std::make_tuple(E)),
-                         Values...);
+    allValueCombinations(Result, std::tuple_cat(Prev, std::make_tuple(E)), Values...);
   }
 }
 
-}  // namespace internal
+} // namespace internal
 
 // CRTP class that enables using enum types as a dimension for
 // makeCartesianProductBenchmark below.
 // The type passed to `B` will be a std::integral_constant<E, e>, with the
 // additional static function `name()` that returns the stringified name of the
 // label.
 //
 // Eg:
 // enum class MyEnum { A, B };
 // struct AllMyEnum : EnumValuesAsTuple<AllMyEnum, MyEnum, 2> {
 //   static constexpr absl::string_view Names[] = {"A", "B"};
 // };
 template <class Derived, class EnumType, size_t NumLabels>
 using EnumValuesAsTuple =
-    decltype(internal::makeEnumValueTuple<Derived, EnumType>(
-        std::make_index_sequence<NumLabels>{}));
+    decltype(internal::makeEnumValueTuple<Derived, EnumType>(std::make_index_sequence<NumLabels>{}));
 
 // Instantiates B<T0, T1, ..., TN> where <Ti...> are the combinations in the
 // cartesian product of `Tuples...`, and pass (arg0, ..., argN) as constructor
 // arguments where `(argi...)` are the combination in the cartesian product of
 // the runtime values of `A...`.
 // B<T...> requires:
 //  - std::string name(args...): The name of the benchmark.
 //  - void run(benchmark::State&, args...): The body of the benchmark.
int makeCartesianProductBenchmark(const Args&... A) {
   return 0;
 }
 
 // When `opaque` is true, this function hides the runtime state of `value` from
 // the optimizer.
 // It returns `value`.
 template <class T>
 TEST_ALWAYS_INLINE inline T maybeOpaque(T value, bool opaque) {
-  if (opaque) benchmark::DoNotOptimize(value);
+  if (opaque)
+    benchmark::DoNotOptimize(value);
   return value;
 }

libcxx/benchmarks/ContainerBenchmarks.h

void BM_ConstructSizeValue(benchmark::State& st, Container, typename Container::value_type const& val) {
   for (auto _ : st) {
     Container c(size, val);
     DoNotOptimizeData(c);
   }
 }
 
 template <class Container, class GenInputs>
 void BM_ConstructIterIter(benchmark::State& st, Container, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto begin = in.begin();
-    const auto end = in.end();
-    benchmark::DoNotOptimize(&in);
-    while (st.KeepRunning()) {
-        Container c(begin, end);
-        DoNotOptimizeData(c);
-    }
+  auto in          = gen(st.range(0));
+  const auto end   = in.end();
 }
 
 template <class Container, class GenInputs>
 void BM_InsertValue(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.end();
-    while (st.KeepRunning()) {
-        c.clear();
-        for (auto it = in.begin(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.insert(*it).first));
-        }
-        benchmark::ClobberMemory();
-    }
+  auto in        = gen(st.range(0));
 }
 
 template <class Container, class GenInputs>
 void BM_InsertValueRehash(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.end();
-    while (st.KeepRunning()) {
-        c.clear();
-        c.rehash(16);
-        for (auto it = in.begin(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.insert(*it).first));
-        }
-        benchmark::ClobberMemory();
-    }
+  auto in        = gen(st.range(0));
 }
 
-
 template <class Container, class GenInputs>
 void BM_InsertDuplicate(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.end();
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(&c);
-    benchmark::DoNotOptimize(&in);
-    while (st.KeepRunning()) {
-        for (auto it = in.begin(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.insert(*it).first));
-        }
-        benchmark::ClobberMemory();
-    }
+  auto in        = gen(st.range(0));
 }
 
-
 template <class Container, class GenInputs>
 void BM_EmplaceDuplicate(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.end();
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(&c);
-    benchmark::DoNotOptimize(&in);
-    while (st.KeepRunning()) {
-        for (auto it = in.begin(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.emplace(*it).first));
-        }
-        benchmark::ClobberMemory();
-    }
+  auto in        = gen(st.range(0));
 }
 
 template <class Container, class GenInputs>
 static void BM_Find(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(&(*c.begin()));
-    const auto end = in.data() + in.size();
-    while (st.KeepRunning()) {
-        for (auto it = in.data(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.find(*it)));
-        }
-        benchmark::ClobberMemory();
-    }
 }
 
 template <class Container, class GenInputs>
 static void BM_FindRehash(benchmark::State& st, Container c, GenInputs gen) {
-    c.rehash(8);
-    auto in = gen(st.range(0));
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(&(*c.begin()));
-    const auto end = in.data() + in.size();
-    while (st.KeepRunning()) {
-        for (auto it = in.data(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.find(*it)));
-        }
-        benchmark::ClobberMemory();
-    }
 }
 
 template <class Container, class GenInputs>
 static void BM_Rehash(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    c.max_load_factor(3.0);
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(c);
-    const auto bucket_count = c.bucket_count();
-    while (st.KeepRunning()) {
-        c.rehash(bucket_count + 1);
-        c.rehash(bucket_count);
-        benchmark::ClobberMemory();
-    }
 }
 
 } // end namespace ContainerBenchmarks
 
 #endif // BENCHMARK_CONTAINER_BENCHMARKS_H

libcxx/benchmarks/GenerateInput.h

 #ifndef BENCHMARK_GENERATE_INPUT_H
 #define BENCHMARK_GENERATE_INPUT_H
 
 #include <algorithm>
-#include <random>
-#include <vector>
-#include <string>
 #include <climits>
 #include <cstddef>
+#include <random>
+#include <string>
+#include <vector>
 
 static const char Letters[] = {
-    '0','1','2','3','4',
-    '5','6','7','8','9',
-    'A','B','C','D','E','F',
-    'G','H','I','J','K',
-    'L','M','N','O','P',
-    'Q','R','S','T','U',
-    'V','W','X','Y','Z',
-    'a','b','c','d','e','f',
-    'g','h','i','j','k',
-    'l','m','n','o','p',
-    'q','r','s','t','u',
-    'v','w','x','y','z'
-};
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
+    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
 static const std::size_t LettersSize = sizeof(Letters);
 
 inline std::default_random_engine& getRandomEngine() {
-    static std::default_random_engine RandEngine(std::random_device{}());
-    return RandEngine;
 }
 
-
 inline char getRandomChar() {
-    std::uniform_int_distribution<> LettersDist(0, LettersSize-1);
-    return Letters[LettersDist(getRandomEngine())];
+  std::uniform_int_distribution<> LettersDist(0, LettersSize - 1);
 }
 
 template <class IntT>
 inline IntT getRandomInteger(IntT Min, IntT Max) {
-    std::uniform_int_distribution<unsigned long long> dist(Min, Max);
-    return static_cast<IntT>(dist(getRandomEngine()));
 }
 
 inline std::string getRandomString(std::size_t Len) {
-    std::string str(Len, 0);
-    std::generate_n(str.begin(), Len, &getRandomChar);
-    return str;
 }
 
 template <class IntT>
 inline std::vector<IntT> getDuplicateIntegerInputs(size_t N) {
-    std::vector<IntT> inputs(N, static_cast<IntT>(-1));
-    return inputs;
 }
 
 template <class IntT>
 inline std::vector<IntT> getSortedIntegerInputs(size_t N) {
-    std::vector<IntT> inputs;
-    for (size_t i=0; i < N; i += 1)
-        inputs.push_back(i);
-    return inputs;
+  for (size_t i = 0; i < N; i += 1)
 }
 
 template <class IntT>
 std::vector<IntT> getSortedLargeIntegerInputs(size_t N) {
-    std::vector<IntT> inputs;
-    for (size_t i=0; i < N; ++i) {
-        inputs.push_back(i + N);
-    }
-    return inputs;
+  for (size_t i = 0; i < N; ++i) {
 }
 
 template <class IntT>
 std::vector<IntT> getSortedTopBitsIntegerInputs(size_t N) {
-    std::vector<IntT> inputs = getSortedIntegerInputs<IntT>(N);
-    for (auto& E : inputs) E <<= ((sizeof(IntT) / 2) * CHAR_BIT);
-    return inputs;
+  for (auto& E : inputs)
+    E <<= ((sizeof(IntT) / 2) * CHAR_BIT);
 }
 
 template <class IntT>
 inline std::vector<IntT> getReverseSortedIntegerInputs(size_t N) {
-    std::vector<IntT> inputs;
-    std::size_t i = N;
-    while (i > 0) {
-        --i;
-        inputs.push_back(i);
-    }
-    return inputs;
 }
 
 template <class IntT>
 std::vector<IntT> getPipeOrganIntegerInputs(size_t N) {
-    std::vector<IntT> v; v.reserve(N);
-    for (size_t i = 0; i < N/2; ++i) v.push_back(i);
-    for (size_t i = N/2; i < N; ++i) v.push_back(N - i);
-    return v;
+  std::vector<IntT> v;
+  v.reserve(N);
+  for (size_t i = 0; i < N / 2; ++i)
+    v.push_back(i);
+  for (size_t i = N / 2; i < N; ++i)
+    v.push_back(N - i);
 }
 
-
 template <class IntT>
 std::vector<IntT> getRandomIntegerInputs(size_t N) {
-    std::vector<IntT> inputs;
-    for (size_t i=0; i < N; ++i) {
-        inputs.push_back(getRandomInteger<IntT>(0, std::numeric_limits<IntT>::max()));
-    }
-    return inputs;
+  for (size_t i = 0; i < N; ++i) {
 }
 
 inline std::vector<std::string> getDuplicateStringInputs(size_t N) {
-    std::vector<std::string> inputs(N, getRandomString(1024));
-    return inputs;
 }
 
 inline std::vector<std::string> getRandomStringInputs(size_t N) {
-    std::vector<std::string> inputs;
-    for (size_t i=0; i < N; ++i) {
-        inputs.push_back(getRandomString(1024));
-    }
-    return inputs;
+  for (size_t i = 0; i < N; ++i) {
 }
 
 inline std::vector<std::string> getSortedStringInputs(size_t N) {
-    std::vector<std::string> inputs = getRandomStringInputs(N);
-    std::sort(inputs.begin(), inputs.end());
-    return inputs;
 }
 
 inline std::vector<std::string> getReverseSortedStringInputs(size_t N) {
-    std::vector<std::string> inputs = getSortedStringInputs(N);
-    std::reverse(inputs.begin(), inputs.end());
-    return inputs;
 }
 
 inline std::vector<const char*> getRandomCStringInputs(size_t N) {
-    static std::vector<std::string> inputs = getRandomStringInputs(N);
-    std::vector<const char*> cinputs;
-    for (auto const& str : inputs)
-        cinputs.push_back(str.c_str());
-    return cinputs;
 }
 
-
 #endif // BENCHMARK_GENERATE_INPUT_H

libcxx/benchmarks/Utilities.h

 #define BENCHMARK_UTILITIES_H
 
 #include <cassert>
 #include <type_traits>
 
 #include "benchmark/benchmark.h"
 
 namespace UtilitiesInternal {
-  template <class Container>
-  auto HaveDataImpl(int) -> decltype((std::declval<Container&>().data(), std::true_type{}));
-  template <class Container>
-  auto HaveDataImpl(long) -> std::false_type;
-  template <class T>
-  using HasData = decltype(HaveDataImpl<T>(0));
 } // namespace UtilitiesInternal
 
 template <class Container, std::enable_if_t<UtilitiesInternal::HasData<Container>::value>* = nullptr>
-void DoNotOptimizeData(Container &c) { benchmark::DoNotOptimize(c.data()); }
+void DoNotOptimizeData(Container& c) {
+  benchmark::DoNotOptimize(c.data());
+}
 template <class Container, std::enable_if_t<!UtilitiesInternal::HasData<Container>::value>* = nullptr>
-void DoNotOptimizeData(Container &c) { benchmark::DoNotOptimize(&c); }
-
+void DoNotOptimizeData(Container& c) {
+  benchmark::DoNotOptimize(&c);
+}
 
 #endif // BENCHMARK_UTILITIES_H

libcxx/benchmarks/VariantBenchmarks.h

 
 template <std::size_t I>
 struct S {
   static constexpr size_t v = I;
 };
 
 template <std::size_t N, std::size_t... Is>
 static auto genVariants(std::index_sequence<Is...>) {
-  using V = std::variant<S<Is>...>;
-  using F = V (*)();
+  using V                 = std::variant<S<Is>...>;
+  using F                 = V (*)();
   static constexpr F fs[] = {[] { return V(std::in_place_index<Is>); }...};
 
   std::array<V, N> result = {};
   for (auto& v : result) {
     v = fs[getRandomInteger(0ul, sizeof...(Is) - 1)]();
   }
 
   return result;
 }
 
 template <std::size_t N, std::size_t Alts>
 static void BM_Visit(benchmark::State& state) {
   auto args = genVariants<N>(std::make_index_sequence<Alts>{});
   for (auto _ : state) {
-    benchmark::DoNotOptimize(std::apply(
-        [](auto... vs) {
-          return std::visit([](auto... is) { return (is.v + ... + 0); }, vs...);
-        },
-        args));
+    benchmark::DoNotOptimize(
+        std::apply([](auto... vs) { return std::visit([](auto... is) { return (is.v + ... + 0); }, vs...); }, args));
   }
 }
 
 } // end namespace VariantBenchmarks
 
 #endif // BENCHMARK_VARIANT_BENCHMARKS_H

libcxx/benchmarks/algorithms.partition_point.bench.cpp

-#include <array>
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cstdint>
 #include <tuple>
 #include <vector>
 
 #include "benchmark/benchmark.h"
 
 #include "CartesianBenchmarks.h"
std::array<I, 10> every_10th_percentile_N(I first, N n) {
 
   return res;
 }
 
 template <class IntT>
 struct TestIntBase {
   static std::vector<IntT> generateInput(size_t size) {
     std::vector<IntT> Res(size);
-    std::generate(Res.begin(), Res.end(),
-                  [] { return getRandomInteger<IntT>(0, std::numeric_limits<IntT>::max()); });
+    std::generate(Res.begin(), Res.end(), [] { return getRandomInteger<IntT>(0, std::numeric_limits<IntT>::max()); });
     return Res;
   }
 };
 
 struct TestInt32 : TestIntBase<std::int32_t> {
   static constexpr const char* Name = "TestInt32";
 };
 
 struct TestInt64 : TestIntBase<std::int64_t> {
   static constexpr const char* Name = "TestInt64";
 };
 
 struct TestUint32 : TestIntBase<std::uint32_t> {
   static constexpr const char* Name = "TestUint32";
 };
 
 struct TestMediumString {
-  static constexpr const char* Name = "TestMediumString";
+  static constexpr const char* Name  = "TestMediumString";
   static constexpr size_t StringSize = 32;
 
   static std::vector<std::string> generateInput(size_t size) {
     std::vector<std::string> Res(size);
     std::generate(Res.begin(), Res.end(), [] { return getRandomString(StringSize); });
     return Res;
   }
 };

 
 using AllAlgs = std::tuple<LowerBoundAlg, UpperBoundAlg, EqualRangeAlg>;
 
 template <class Alg, class TestType>
 struct PartitionPointBench {
   size_t Quantity;
 
   std::string name() const {
-    return std::string("PartitionPointBench_") + Alg::Name + "_" +
-           TestType::Name + '/' + std::to_string(Quantity);
+    return std::string("PartitionPointBench_") + Alg::Name + "_" + TestType::Name + '/' + std::to_string(Quantity);
   }
 
   void run(benchmark::State& state) const {
     auto Data = TestType::generateInput(Quantity);
     std::sort(Data.begin(), Data.end());
     auto Every10Percentile = every_10th_percentile_N(Data.begin(), Data.size());
 
     for (auto _ : state) {
       for (auto Test : Every10Percentile)
         benchmark::DoNotOptimize(Alg{}(Data.begin(), Data.end(), *Test));
     }
   }
 };
 
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
 
   const std::vector<size_t> Quantities = {1 << 8, 1 << 10, 1 << 20};
-  makeCartesianProductBenchmark<PartitionPointBench, AllAlgs, AllTestTypes>(
-      Quantities);
+  makeCartesianProductBenchmark<PartitionPointBench, AllAlgs, AllTestTypes>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/common.h

 #include <tuple>
 #include <vector>
 
 #include "../CartesianBenchmarks.h"
 #include "../GenerateInput.h"
 
 enum class ValueType { Uint32, Uint64, Pair, Tuple, String, Float };
 struct AllValueTypes : EnumValuesAsTuple<AllValueTypes, ValueType, 6> {
-  static constexpr const char* Names[] = {"uint32", "uint64", "pair<uint32, uint32>", "tuple<uint32, uint64, uint32>",
-                                          "string", "float"};
+  static constexpr const char* Names[] = {
+      "uint32", "uint64", "pair<uint32, uint32>", "tuple<uint32, uint64, uint32>", "string", "float"};
 };
 
-using Types = std::tuple< uint32_t, uint64_t, std::pair<uint32_t, uint32_t>, std::tuple<uint32_t, uint64_t, uint32_t>,
-                          std::string, float >;
+using Types =
+    std::tuple< uint32_t,
+                uint64_t,
+                std::pair<uint32_t, uint32_t>,
+                std::tuple<uint32_t, uint64_t, uint32_t>,
+                std::string,
+                float >;
 
 template <class V>
 using Value = std::tuple_element_t<(int)V::value, Types>;
 
 enum class Order {
   Random,
   Ascending,
   Descending,
   SingleElement,
   PipeOrgan,
   Heap,
   QuickSortAdversary,
 };
 struct AllOrders : EnumValuesAsTuple<AllOrders, Order, 7> {
-  static constexpr const char* Names[] = {"Random",     "Ascending",
-                                          "Descending", "SingleElement",
-                                          "PipeOrgan",  "Heap",
-                                          "QuickSortAdversary"};
+  static constexpr const char* Names[] = {
+      "Random", "Ascending", "Descending", "SingleElement", "PipeOrgan", "Heap", "QuickSortAdversary"};
 };
 
 // fillAdversarialQuickSortInput fills the input vector with N int-like values.
 // These values are arranged in such a way that they would invoke O(N^2)
 // behavior on any quick sort implementation that satisifies certain conditions.
 // Details are available in the following paper:
 // "A Killer Adversary for Quicksort", M. D. McIlroy, Software-Practice &
 // Experience Volume 29 Issue 4 April 10, 1999 pp 341-344.
 // https://dl.acm.org/doi/10.5555/311868.311871.
 template <class T>
 void fillAdversarialQuickSortInput(T& V, size_t N) {
   assert(N > 0);
   // If an element is equal to gas, it indicates that the value of the element
   // is still to be decided and may change over the course of time.
   const unsigned int gas = N - 1;
   V.resize(N);
   for (unsigned int i = 0; i < N; ++i) {
     V[i] = gas;
   }
   // Candidate for the pivot position.
   int candidate = 0;
-  int nsolid = 0;
+  int nsolid    = 0;
   // Populate all positions in the generated input to gas.
   std::vector<int> ascVals(V.size());
   // Fill up with ascending values from 0 to V.size()-1.  These will act as
   // indices into V.
   std::iota(ascVals.begin(), ascVals.end(), 0);
   std::sort(ascVals.begin(), ascVals.end(), [&](int x, int y) {
     if (V[x] == gas && V[y] == gas) {
       // We are comparing two inputs whose value is still to be decided.

 constexpr size_t TestSetElements =
 #if !TEST_HAS_FEATURE(memory_sanitizer)
     1 << 18;
 #else
     1 << 14;
 #endif
 
 template <class ValueType>
-std::vector<std::vector<Value<ValueType> > > makeOrderedValues(size_t N,
-                                                               Order O) {
+std::vector<std::vector<Value<ValueType> > > makeOrderedValues(size_t N, Order O) {
   std::vector<std::vector<Value<ValueType> > > Ret;
   const size_t NumCopies = std::max(size_t{1}, TestSetElements / N);
   Ret.resize(NumCopies);
   for (auto& V : Ret) {
     fillValues(V, N, O);
     sortValues(V, O);
   }
   return Ret;
 }
 
 template <class T, class U>
-TEST_ALWAYS_INLINE void resetCopies(benchmark::State& state, T& Copies,
-                                    U& Orig) {
+TEST_ALWAYS_INLINE void resetCopies(benchmark::State& state, T& Copies, U& Orig) {
   state.PauseTiming();
   for (auto& Copy : Copies)
     Copy = Orig;
   state.ResumeTiming();
 }
 
 enum class BatchSize {
   CountElements,
   CountBatch,
 };
 
 template <class ValueType, class F>
-void runOpOnCopies(benchmark::State& state, size_t Quantity, Order O,
-                   BatchSize Count, F Body) {
+void runOpOnCopies(benchmark::State& state, size_t Quantity, Order O, BatchSize Count, F Body) {
   auto Copies = makeOrderedValues<ValueType>(Quantity, O);
-  auto Orig = Copies;
+  auto Orig   = Copies;
 
-  const size_t Batch = Count == BatchSize::CountElements
-                           ? Copies.size() * Quantity
-                           : Copies.size();
+  const size_t Batch = Count == BatchSize::CountElements ? Copies.size() * Quantity : Copies.size();
   while (state.KeepRunningBatch(Batch)) {
     for (auto& Copy : Copies) {
       Body(Copy);
       benchmark::DoNotOptimize(Copy);
     }
     state.PauseTiming();
     Copies = Orig;
     state.ResumeTiming();
   }
 }
 
-
-const std::vector<size_t> Quantities = {1 << 0, 1 << 2,  1 << 4,  1 << 6,
-                                        1 << 8, 1 << 10, 1 << 14,
-    // Running each benchmark in parallel consumes too much memory with MSAN
-    // and can lead to the test process being killed.
+const std::vector<size_t> Quantities = {
+    1 << 0,
+    1 << 2,
+    1 << 4,
+    1 << 6,
+    1 << 8,
+    1 << 10,
+    1 << 14,
 #if !TEST_HAS_FEATURE(memory_sanitizer)
-                                        1 << 18
 #endif
 };
 
 #endif // LIBCXX_ALGORITHMS_COMMON_H

libcxx/benchmarks/algorithms/lower_bound.bench.cpp

 
 #include "common.h"
 
 namespace {
 template <class ValueType>
 struct LowerBound {
   size_t Quantity;
 
-  mutable std::mt19937_64 rng { std::random_device{}() };
+  mutable std::mt19937_64 rng{std::random_device{}()};
 
   void run(benchmark::State& state) const {
     runOpOnCopies<ValueType>(state, Quantity, Order::Ascending, BatchSize::CountBatch, [&](auto& Copy) {
       auto result = std::lower_bound(Copy.begin(), Copy.end(), Copy[rng() % Copy.size()]);
       benchmark::DoNotOptimize(result);
     });
   }
 
-  std::string name() const {
-    return "BM_LowerBound" + ValueType::name() + "_" + std::to_string(Quantity);
-  }
+  std::string name() const { return "BM_LowerBound" + ValueType::name() + "_" + std::to_string(Quantity); }
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<LowerBound, AllValueTypes>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/make_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct MakeHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements,
-        [](auto& Copy) { std::make_heap(Copy.begin(), Copy.end()); });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
+      std::make_heap(Copy.begin(), Copy.end());
+    });
   }
 
   std::string name() const {
-    return "BM_MakeHeap" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_MakeHeap" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<MakeHeap, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/make_heap_then_sort_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct MakeThenSortHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements,
-                             [](auto& Copy) {
-                               std::make_heap(Copy.begin(), Copy.end());
-                               std::sort_heap(Copy.begin(), Copy.end());
-                             });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
   }
 
   std::string name() const {
-    return "BM_MakeThenSortHeap" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_MakeThenSortHeap" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<MakeThenSortHeap, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/pop_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType>
 struct PopHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
-          for (auto B = Copy.begin(), I = Copy.end(); I != B; --I) {
-            std::pop_heap(B, I);
-          }
-        });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
   }
 
-  std::string name() const {
-    return "BM_PopHeap" + ValueType::name() + "_" + std::to_string(Quantity);
-  };
+  std::string name() const { return "BM_PopHeap" + ValueType::name() + "_" + std::to_string(Quantity); };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<PopHeap, AllValueTypes>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/push_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct PushHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
-          for (auto I = Copy.begin(), E = Copy.end(); I != E; ++I) {
-            std::push_heap(Copy.begin(), I + 1);
-          }
-        });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
   }
 
   bool skip() const { return Order() == ::Order::Heap; }
 
   std::string name() const {
-    return "BM_PushHeap" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_PushHeap" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<PushHeap, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/ranges_make_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct RangesMakeHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements,
-        [](auto& Copy) { std::ranges::make_heap(Copy); });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
+      std::ranges::make_heap(Copy);
+    });
   }
 
   std::string name() const {
-    return "BM_RangesMakeHeap" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_RangesMakeHeap" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<RangesMakeHeap, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/ranges_make_heap_then_sort_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct RangesMakeThenSortHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements,
-                             [](auto& Copy) {
-                               std::ranges::make_heap(Copy);
-                               std::ranges::sort_heap(Copy);
-                             });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
   }
 
   std::string name() const {
-    return "BM_RangesMakeThenSortHeap" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_RangesMakeThenSortHeap" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<RangesMakeThenSortHeap, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/ranges_pop_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType>
 struct RangesPopHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
-          for (auto B = Copy.begin(), I = Copy.end(); I != B; --I) {
-            std::ranges::pop_heap(B, I);
-          }
-        });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
   }
 
-  std::string name() const {
-    return "BM_RangesPopHeap" + ValueType::name() + "_" + std::to_string(Quantity);
-  };
+  std::string name() const { return "BM_RangesPopHeap" + ValueType::name() + "_" + std::to_string(Quantity); };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<RangesPopHeap, AllValueTypes>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/ranges_push_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct RangesPushHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
-          for (auto I = Copy.begin(), E = Copy.end(); I != E; ++I) {
-            std::ranges::push_heap(Copy.begin(), I + 1);
-          }
-        });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
   }
 
   bool skip() const { return Order() == ::Order::Heap; }
 
   std::string name() const {
-    return "BM_RangesPushHeap" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_RangesPushHeap" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<RangesPushHeap, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/ranges_sort.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct Sort {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements,
-        [](auto& Copy) { std::ranges::sort(Copy); });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
+      std::ranges::sort(Copy);
+    });
   }
 
   bool skip() const { return Order() == ::Order::Heap; }
 
   std::string name() const {
-    return "BM_RangesSort" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_RangesSort" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   }
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<Sort, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/ranges_sort_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType>
 struct RangesSortHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order::Heap, BatchSize::CountElements,
-        [](auto& Copy) { std::ranges::sort_heap(Copy); });
+    runOpOnCopies<ValueType>(state, Quantity, Order::Heap, BatchSize::CountElements, [](auto& Copy) {
+      std::ranges::sort_heap(Copy);
+    });
   }
 
-  std::string name() const {
-    return "BM_RangesSortHeap" + ValueType::name() + "_" + std::to_string(Quantity);
-  };
+  std::string name() const { return "BM_RangesSortHeap" + ValueType::name() + "_" + std::to_string(Quantity); };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<RangesSortHeap, AllValueTypes>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/ranges_stable_sort.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct StableSort {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements,
-        [](auto& Copy) { std::ranges::stable_sort(Copy); });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
+      std::ranges::stable_sort(Copy);
+    });
   }
 
   bool skip() const { return Order() == ::Order::Heap; }
 
   std::string name() const {
-    return "BM_RangesStableSort" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_RangesStableSort" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   }
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<StableSort, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/sort.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct Sort {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements,
-        [](auto& Copy) { std::sort(Copy.begin(), Copy.end()); });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
+      std::sort(Copy.begin(), Copy.end());
+    });
   }
 
   bool skip() const { return Order() == ::Order::Heap; }
 
-  std::string name() const {
-    return "BM_Sort" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
-  };
+  std::string name() const { return "BM_Sort" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity); };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<Sort, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/sort_heap.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType>
 struct SortHeap {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order::Heap, BatchSize::CountElements,
-        [](auto& Copy) { std::sort_heap(Copy.begin(), Copy.end()); });
+    runOpOnCopies<ValueType>(state, Quantity, Order::Heap, BatchSize::CountElements, [](auto& Copy) {
+      std::sort_heap(Copy.begin(), Copy.end());
+    });
   }
 
-  std::string name() const {
-    return "BM_SortHeap" + ValueType::name() + "_" + std::to_string(Quantity);
-  };
+  std::string name() const { return "BM_SortHeap" + ValueType::name() + "_" + std::to_string(Quantity); };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<SortHeap, AllValueTypes>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/algorithms/stable_sort.bench.cpp

 #include "common.h"
 
 namespace {
 template <class ValueType, class Order>
 struct StableSort {
   size_t Quantity;
 
   void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(
-        state, Quantity, Order(), BatchSize::CountElements,
-        [](auto& Copy) { std::stable_sort(Copy.begin(), Copy.end()); });
+    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
+      std::stable_sort(Copy.begin(), Copy.end());
+    });
   }
 
   bool skip() const { return Order() == ::Order::Heap; }
 
   std::string name() const {
-    return "BM_StableSort" + ValueType::name() + Order::name() + "_" +
-           std::to_string(Quantity);
+    return "BM_StableSort" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
   };
 };
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
   makeCartesianProductBenchmark<StableSort, AllValueTypes, AllOrders>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/allocation.bench.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "benchmark/benchmark.h"
 
+#include <cassert>
 #include <new>
 #include <vector>
-#include <cassert>
 
 struct PointerList {
   PointerList* Next = nullptr;
 };
 
 struct MallocWrapper {
-  __attribute__((always_inline))
-  static void* Allocate(size_t N) {
-    return std::malloc(N);
-  }
-  __attribute__((always_inline))
-  static void Deallocate(void* P, size_t) {
-    std::free(P);
-  }
+  __attribute__((always_inline)) static void* Allocate(size_t N) { return std::malloc(N); }
+  __attribute__((always_inline)) static void Deallocate(void* P, size_t) { std::free(P); }
 };
 
 struct NewWrapper {
-  __attribute__((always_inline))
-  static void* Allocate(size_t N) {
-    return ::operator new(N);
-  }
-  __attribute__((always_inline))
-  static void Deallocate(void* P, size_t) {
-    ::operator delete(P);
-  }
+  __attribute__((always_inline)) static void* Allocate(size_t N) { return ::operator new(N); }
+  __attribute__((always_inline)) static void Deallocate(void* P, size_t) { ::operator delete(P); }
 };
 
 struct BuiltinNewWrapper {
-  __attribute__((always_inline))
-  static void* Allocate(size_t N) {
-    return __builtin_operator_new(N);
-  }
-  __attribute__((always_inline))
-  static void Deallocate(void* P, size_t) {
-    __builtin_operator_delete(P);
-  }
+  __attribute__((always_inline)) static void* Allocate(size_t N) { return __builtin_operator_new(N); }
+  __attribute__((always_inline)) static void Deallocate(void* P, size_t) { __builtin_operator_delete(P); }
 };
 
 struct BuiltinSizedNewWrapper {
-  __attribute__((always_inline))
-  static void* Allocate(size_t N) {
-    return __builtin_operator_new(N);
-  }
-  __attribute__((always_inline))
-  static void Deallocate(void* P, size_t N) {
-    __builtin_operator_delete(P, N);
-  }
+  __attribute__((always_inline)) static void* Allocate(size_t N) { return __builtin_operator_new(N); }
+  __attribute__((always_inline)) static void Deallocate(void* P, size_t N) { __builtin_operator_delete(P, N); }
 };
 
-
 template <class AllocWrapper>
 static void BM_AllocateAndDeallocate(benchmark::State& st) {
   const size_t alloc_size = st.range(0);
   while (st.KeepRunning()) {
     void* p = AllocWrapper::Allocate(alloc_size);
     benchmark::DoNotOptimize(p);
     AllocWrapper::Deallocate(p, alloc_size);
   }
 }
 
-
 template <class AllocWrapper>
 static void BM_AllocateOnly(benchmark::State& st) {
   const size_t alloc_size = st.range(0);
-  PointerList *Start = nullptr;
+  PointerList* Start      = nullptr;
 
   while (st.KeepRunning()) {
     PointerList* p = (PointerList*)AllocWrapper::Allocate(alloc_size);
     benchmark::DoNotOptimize(p);
     p->Next = Start;
-    Start = p;
+    Start   = p;
   }
 
-  PointerList *Next = Start;
+  PointerList* Next = Start;
   while (Next) {
-    PointerList *Tmp = Next;
-    Next = Tmp->Next;
+    PointerList* Tmp = Next;
+    Next             = Tmp->Next;
     AllocWrapper::Deallocate(Tmp, alloc_size);
   }
 }
 
 template <class AllocWrapper>
 static void BM_DeallocateOnly(benchmark::State& st) {
   const size_t alloc_size = st.range(0);
-  const auto NumAllocs = st.max_iterations;
+  const auto NumAllocs    = st.max_iterations;
 
   std::vector<void*> Pointers(NumAllocs);
   for (auto& p : Pointers) {
     p = AllocWrapper::Allocate(alloc_size);
   }
 
-  void** Data = Pointers.data();
+  void** Data      = Pointers.data();
   void** const End = Pointers.data() + Pointers.size();
   while (st.KeepRunning()) {
     AllocWrapper::Deallocate(*Data, alloc_size);
     Data += 1;
   }
   assert(Data == End);
 }
 
 static int RegisterAllocBenchmarks() {
-  using FnType = void(*)(benchmark::State&);
+  using FnType = void (*)(benchmark::State&);
   struct {
     const char* name;
     FnType func;
   } TestCases[] = {
       {"BM_Malloc", &BM_AllocateAndDeallocate<MallocWrapper>},
       {"BM_New", &BM_AllocateAndDeallocate<NewWrapper>},
       {"BM_BuiltinNewDelete", BM_AllocateAndDeallocate<BuiltinNewWrapper>},
       {"BM_BuiltinSizedNewDelete", BM_AllocateAndDeallocate<BuiltinSizedNewWrapper>},

libcxx/benchmarks/deque.bench.cpp

 
 #include "ContainerBenchmarks.h"
 #include "GenerateInput.h"
 
 using namespace ContainerBenchmarks;
 
 constexpr std::size_t TestNumInputs = 1024;
 
-BENCHMARK_CAPTURE(BM_ConstructSize,
-    deque_byte,
-    std::deque<unsigned char>{})->Arg(5140480);
-
-BENCHMARK_CAPTURE(BM_ConstructSizeValue,
-    deque_byte,
-    std::deque<unsigned char>{}, 0)->Arg(5140480);
-
-BENCHMARK_CAPTURE(BM_ConstructIterIter,
-  deque_char,
-  std::deque<char>{},
-  getRandomIntegerInputs<char>)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_ConstructIterIter,
-  deque_size_t,
-  std::deque<size_t>{},
-  getRandomIntegerInputs<size_t>)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_ConstructIterIter,
-  deque_string,
-  std::deque<std::string>{},
-  getRandomStringInputs)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_ConstructSize, deque_byte, std::deque<unsigned char>{})->Arg(5140480);
 
+BENCHMARK_CAPTURE(BM_ConstructSizeValue, deque_byte, std::deque<unsigned char>{}, 0)->Arg(5140480);
 
+BENCHMARK_CAPTURE(BM_ConstructIterIter, deque_char, std::deque<char>{}, getRandomIntegerInputs<char>)
+    ->Arg(TestNumInputs);
 
+BENCHMARK_CAPTURE(BM_ConstructIterIter, deque_size_t, std::deque<size_t>{}, getRandomIntegerInputs<size_t>)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(BM_ConstructIterIter, deque_string, std::deque<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_MAIN();

libcxx/benchmarks/filesystem.bench.cpp

-#include "benchmark/benchmark.h"
 #include "GenerateInput.h"
-#include "test_iterators.h"
+#include "benchmark/benchmark.h"
 #include "filesystem_include.h"
+#include "test_iterators.h"
 
 static const size_t TestNumInputs = 1024;
 
-
 template <class GenInputs>
-void BM_PathConstructString(benchmark::State &st, GenInputs gen) {
+void BM_PathConstructString(benchmark::State& st, GenInputs gen) {
   using fs::path;
   const auto in = gen(st.range(0));
   path PP;
   for (auto& Part : in)
     PP /= Part;
   benchmark::DoNotOptimize(PP.native().data());
   while (st.KeepRunning()) {
     const path P(PP.native());
     benchmark::DoNotOptimize(P.native().data());
   }
   st.SetComplexityN(st.range(0));
 }
-BENCHMARK_CAPTURE(BM_PathConstructString, large_string,
-  getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
-
+BENCHMARK_CAPTURE(BM_PathConstructString, large_string, getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
 
 template <class GenInputs>
-void BM_PathConstructCStr(benchmark::State &st, GenInputs gen) {
+void BM_PathConstructCStr(benchmark::State& st, GenInputs gen) {
   using fs::path;
   const auto in = gen(st.range(0));
   path PP;
   for (auto& Part : in)
     PP /= Part;
   benchmark::DoNotOptimize(PP.native().data());
   while (st.KeepRunning()) {
     const path P(PP.native().c_str());
     benchmark::DoNotOptimize(P.native().data());
   }
 }
-BENCHMARK_CAPTURE(BM_PathConstructCStr, large_string,
-  getRandomStringInputs)->Arg(TestNumInputs);
-
+BENCHMARK_CAPTURE(BM_PathConstructCStr, large_string, getRandomStringInputs)->Arg(TestNumInputs);
 
 template <template <class...> class ItType, class GenInputs>
-void BM_PathConstructIter(benchmark::State &st, GenInputs gen) {
+void BM_PathConstructIter(benchmark::State& st, GenInputs gen) {
   using fs::path;
-  using Iter = ItType<std::string::const_iterator>;
+  using Iter    = ItType<std::string::const_iterator>;
   const auto in = gen(st.range(0));
   path PP;
   for (auto& Part : in)
     PP /= Part;
   auto Start = Iter(PP.native().begin());
-  auto End = Iter(PP.native().end());
+  auto End   = Iter(PP.native().end());
   benchmark::DoNotOptimize(PP.native().data());
   benchmark::DoNotOptimize(Start);
   benchmark::DoNotOptimize(End);
   while (st.KeepRunning()) {
     const path P(Start, End);
     benchmark::DoNotOptimize(P.native().data());
   }
   st.SetComplexityN(st.range(0));
 }
 template <class GenInputs>
-void BM_PathConstructInputIter(benchmark::State &st, GenInputs gen) {
+void BM_PathConstructInputIter(benchmark::State& st, GenInputs gen) {
   BM_PathConstructIter<cpp17_input_iterator>(st, gen);
 }
 template <class GenInputs>
-void BM_PathConstructForwardIter(benchmark::State &st, GenInputs gen) {
+void BM_PathConstructForwardIter(benchmark::State& st, GenInputs gen) {
   BM_PathConstructIter<forward_iterator>(st, gen);
 }
-BENCHMARK_CAPTURE(BM_PathConstructInputIter, large_string,
-  getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
-BENCHMARK_CAPTURE(BM_PathConstructForwardIter, large_string,
-  getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
-
+BENCHMARK_CAPTURE(BM_PathConstructInputIter, large_string, getRandomStringInputs)
+    ->Range(8, TestNumInputs)
+    ->Complexity();
+BENCHMARK_CAPTURE(BM_PathConstructForwardIter, large_string, getRandomStringInputs)
+    ->Range(8, TestNumInputs)
+    ->Complexity();
 
 template <class GenInputs>
-void BM_PathIterateMultipleTimes(benchmark::State &st, GenInputs gen) {
+void BM_PathIterateMultipleTimes(benchmark::State& st, GenInputs gen) {
   using fs::path;
   const auto in = gen(st.range(0));
   path PP;
   for (auto& Part : in)
     PP /= Part;
   benchmark::DoNotOptimize(PP.native().data());
   while (st.KeepRunning()) {
     for (auto const& E : PP) {
       benchmark::DoNotOptimize(E.native().data());
     }
     benchmark::ClobberMemory();
   }
   st.SetComplexityN(st.range(0));
 }
-BENCHMARK_CAPTURE(BM_PathIterateMultipleTimes, iterate_elements,
-  getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
-
+BENCHMARK_CAPTURE(BM_PathIterateMultipleTimes, iterate_elements, getRandomStringInputs)
+    ->Range(8, TestNumInputs)
+    ->Complexity();
 
 template <class GenInputs>
-void BM_PathIterateOnce(benchmark::State &st, GenInputs gen) {
+void BM_PathIterateOnce(benchmark::State& st, GenInputs gen) {
   using fs::path;
   const auto in = gen(st.range(0));
   path PP;
   for (auto& Part : in)
     PP /= Part;
   benchmark::DoNotOptimize(PP.native().data());
   while (st.KeepRunning()) {
     const path P = PP.native();
     for (auto const& E : P) {
       benchmark::DoNotOptimize(E.native().data());
     }
     benchmark::ClobberMemory();
   }
   st.SetComplexityN(st.range(0));
 }
-BENCHMARK_CAPTURE(BM_PathIterateOnce, iterate_elements,
-  getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
+BENCHMARK_CAPTURE(BM_PathIterateOnce, iterate_elements, getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
 
 template <class GenInputs>
-void BM_PathIterateOnceBackwards(benchmark::State &st, GenInputs gen) {
+void BM_PathIterateOnceBackwards(benchmark::State& st, GenInputs gen) {
   using fs::path;
   const auto in = gen(st.range(0));
   path PP;
   for (auto& Part : in)
     PP /= Part;
   benchmark::DoNotOptimize(PP.native().data());
   while (st.KeepRunning()) {
     const path P = PP.native();
     const auto B = P.begin();
-    auto I = P.end();
+    auto I       = P.end();
     while (I != B) {
       --I;
       benchmark::DoNotOptimize(*I);
     }
     benchmark::DoNotOptimize(*I);
   }
 }
-BENCHMARK_CAPTURE(BM_PathIterateOnceBackwards, iterate_elements,
-  getRandomStringInputs)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_PathIterateOnceBackwards, iterate_elements, getRandomStringInputs)->Arg(TestNumInputs);
 
 static fs::path getRandomPaths(int NumParts, int PathLen) {
   fs::path Result;
   while (NumParts--) {
     std::string Part = getRandomString(PathLen);
     Result /= Part;
   }
   return Result;
 }
 
 template <class GenInput>
-void BM_LexicallyNormal(benchmark::State &st, GenInput gen, size_t PathLen) {
+void BM_LexicallyNormal(benchmark::State& st, GenInput gen, size_t PathLen) {
   using fs::path;
   auto In = gen(st.range(0), PathLen);
   benchmark::DoNotOptimize(&In);
   while (st.KeepRunning()) {
     benchmark::DoNotOptimize(In.lexically_normal());
   }
   st.SetComplexityN(st.range(0));
 }
-BENCHMARK_CAPTURE(BM_LexicallyNormal, small_path,
-  getRandomPaths, /*PathLen*/5)->RangeMultiplier(2)->Range(2, 256)->Complexity();
-BENCHMARK_CAPTURE(BM_LexicallyNormal, large_path,
-  getRandomPaths, /*PathLen*/32)->RangeMultiplier(2)->Range(2, 256)->Complexity();
+BENCHMARK_CAPTURE(BM_LexicallyNormal, small_path, getRandomPaths, /*PathLen*/ 5)
+    ->RangeMultiplier(2)
+    ->Range(2, 256)
+    ->Complexity();
+BENCHMARK_CAPTURE(BM_LexicallyNormal, large_path, getRandomPaths, /*PathLen*/ 32)
+    ->RangeMultiplier(2)
+    ->Range(2, 256)
+    ->Complexity();
 
 BENCHMARK_MAIN();

libcxx/benchmarks/format_to.bench.cpp

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <format>
 
-#include <iterator>
 #include <algorithm>
 #include <array>
+#include <iterator>
 #include <list>
 #include <span>
 #include <string>
 #include <vector>
 
 #include "benchmark/benchmark.h"
 #include "make_string.h"
 
 #define CSTR(S) MAKE_CSTRING(CharT, S)
 
 /*** Back inserter ***/
 
 template <class Container>
 static void BM_format_to_string_back_inserter(benchmark::State& state) {
   using CharT = typename Container::value_type;
   size_t size = state.range(0);
-  auto str = std::basic_string<CharT>(size, CharT('*'));
+  auto str    = std::basic_string<CharT>(size, CharT('*'));
 
   for (auto _ : state) {
     Container output;
     benchmark::DoNotOptimize(std::format_to(std::back_inserter(output), CSTR("{}"), str));
   }
   state.SetBytesProcessed(state.iterations() * size * sizeof(CharT));
 }
 
 /*** Begin ***/
 
 template <class Container>
 static void BM_format_to_string_begin(benchmark::State& state) {
   using CharT = typename Container::value_type;
   size_t size = state.range(0);
-  auto str = std::basic_string<CharT>(size, CharT('*'));
+  auto str    = std::basic_string<CharT>(size, CharT('*'));
 
   Container output(size, CharT('-'));
   for (auto _ : state)
     benchmark::DoNotOptimize(std::format_to(std::begin(output), CSTR("{}"), str));
 
   state.SetBytesProcessed(state.iterations() * size * sizeof(CharT));
 }
 
 /*** Pointer ***/
 
 template <class CharT>
 static void BM_format_to_string_span(benchmark::State& state) {
   size_t size = state.range(0);
-  auto str = std::basic_string<CharT>(size, CharT('*'));
+  auto str    = std::basic_string<CharT>(size, CharT('*'));
 
   auto buffer = std::basic_string<CharT>(size, CharT('-'));
   std::span<CharT> output{buffer};
   for (auto _ : state)
     benchmark::DoNotOptimize(std::format_to(std::begin(output), CSTR("{}"), str));
 
   state.SetBytesProcessed(state.iterations() * size * sizeof(CharT));
 }
 
 template <class CharT>
 static void BM_format_to_string_pointer(benchmark::State& state) {
   size_t size = state.range(0);
-  auto str = std::basic_string<CharT>(size, CharT('*'));
+  auto str    = std::basic_string<CharT>(size, CharT('*'));
 
-  auto buffer = std::basic_string<CharT>(size, CharT('-'));
+  auto buffer   = std::basic_string<CharT>(size, CharT('-'));
   CharT* output = buffer.data();
   for (auto _ : state)
     benchmark::DoNotOptimize(std::format_to(output, CSTR("{}"), str));
 
   state.SetBytesProcessed(state.iterations() * size * sizeof(CharT));
 }
 
 /*** Main ***/

libcxx/benchmarks/format_to_n.bench.cpp

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <format>
 
-#include <iterator>
 #include <algorithm>
 #include <array>
+#include <iterator>
 #include <list>
 #include <span>
 #include <string>
 #include <vector>
 
 #include "benchmark/benchmark.h"
 #include "make_string.h"
 
 #define CSTR(S) MAKE_CSTRING(CharT, S)
 
 /*** Back inserter ***/
 
 template <class Container>
 static void BM_format_to_n_string_back_inserter(benchmark::State& state) {
   using CharT = typename Container::value_type;
   size_t size = state.range(0);
-  auto str = std::basic_string<CharT>(2 * size, CharT('*'));
+  auto str    = std::basic_string<CharT>(2 * size, CharT('*'));
 
   for (auto _ : state) {
     Container output;
     benchmark::DoNotOptimize(std::format_to_n(std::back_inserter(output), size, CSTR("{}"), str));
   }
   state.SetBytesProcessed(state.iterations() * size * sizeof(CharT));
 }
 
 /*** Begin ***/
 
 template <class Container>
 static void BM_format_to_n_string_begin(benchmark::State& state) {
   using CharT = typename Container::value_type;
   size_t size = state.range(0);
-  auto str = std::basic_string<CharT>(2 * size, CharT('*'));
+  auto str    = std::basic_string<CharT>(2 * size, CharT('*'));
 
   Container output(size, CharT('-'));
   for (auto _ : state)
     benchmark::DoNotOptimize(std::format_to_n(std::begin(output), size, CSTR("{}"), str));
 
   state.SetBytesProcessed(state.iterations() * size * sizeof(CharT));
 }
 
 /*** Pointer ***/
 
 template <class CharT>
 static void BM_format_to_n_string_span(benchmark::State& state) {
   size_t size = state.range(0);
-  auto str = std::basic_string<CharT>(2 * size, CharT('*'));
+  auto str    = std::basic_string<CharT>(2 * size, CharT('*'));
 
   auto buffer = std::basic_string<CharT>(size, CharT('-'));
   std::span<CharT> output{buffer};
   for (auto _ : state)
     benchmark::DoNotOptimize(std::format_to_n(std::begin(output), size, CSTR("{}"), str));
 
   state.SetBytesProcessed(state.iterations() * size * sizeof(CharT));
 }
 
 template <class CharT>
 static void BM_format_to_n_string_pointer(benchmark::State& state) {
   size_t size = state.range(0);
-  auto str = std::basic_string<CharT>(2 * size, CharT('*'));
+  auto str    = std::basic_string<CharT>(2 * size, CharT('*'));
 
-  auto buffer = std::basic_string<CharT>(size, CharT('-'));
+  auto buffer   = std::basic_string<CharT>(size, CharT('-'));
   CharT* output = buffer.data();
   for (auto _ : state)
     benchmark::DoNotOptimize(std::format_to_n(output, size, CSTR("{}"), str));
 
   state.SetBytesProcessed(state.iterations() * size * sizeof(CharT));
 }
 
 /*** Main ***/

libcxx/benchmarks/formatter_float.bench.cpp

 enum class DisplayTypeE {
   Default,
   Hex,
   Scientific,
   Fixed,
   General,
 };
 struct AllDisplayTypes : EnumValuesAsTuple<AllDisplayTypes, DisplayTypeE, 5> {
-  static constexpr const char* Names[] = {"DisplayDefault", "DisplayHex", "DisplayScientific", "DisplayFixed",
-                                          "DisplayGeneral"};
+  static constexpr const char* Names[] = {
+      "DisplayDefault", "DisplayHex", "DisplayScientific", "DisplayFixed", "DisplayGeneral"};
 };
 
 template <DisplayTypeE E>
 struct DisplayType {};
 
 template <>
 struct DisplayType<DisplayTypeE::Default> {
   static constexpr const char* fmt = "";

 template <>
 struct DisplayType<DisplayTypeE::General> {
   static constexpr const char* fmt = "g";
 };
 
 // *** Alignment ***
 enum class AlignmentE { None, Left, Center, Right, ZeroPadding };
 struct AllAlignments : EnumValuesAsTuple<AllAlignments, AlignmentE, 5> {
-  static constexpr const char* Names[] = {"AlignNone", "AlignmentLeft", "AlignmentCenter", "AlignmentRight",
-                                          "ZeroPadding"};
+  static constexpr const char* Names[] = {
+      "AlignNone", "AlignmentLeft", "AlignmentCenter", "AlignmentRight", "ZeroPadding"};
 };
 
 template <AlignmentE E>
 struct Alignment {};
 
 template <>
 struct Alignment<AlignmentE::None> {
   static constexpr const char* fmt = "";
struct FloatingPoint {
   }();
 };
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
 
-  makeCartesianProductBenchmark<FloatingPoint, AllLocalizations, AllDisplayTypes, AllTypes, AllValues, AllAlignments,
+  makeCartesianProductBenchmark<FloatingPoint,
+                                AllLocalizations,
+                                AllDisplayTypes,
+                                AllTypes,
+                                AllValues,
+                                AllAlignments,
                                 AllPrecisions>();
 
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/formatter_int.bench.cpp

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <array>
 #include <format>
 #include <random>
 
-#include "benchmark/benchmark.h"
 #include "CartesianBenchmarks.h"
+#include "benchmark/benchmark.h"
 
 // Tests the full range of the value.
 template <class T>
-static std::array<T, 1000>
-generate(std::uniform_int_distribution<T> distribution = std::uniform_int_distribution<T>{
+static std::array<T, 1000> generate(std::uniform_int_distribution<T> distribution = std::uniform_int_distribution<T>{
                                         std::numeric_limits<T>::min(), std::numeric_limits<T>::max()}) {
   std::mt19937 generator;
   std::array<T, 1000> result;
   std::generate_n(result.begin(), result.size(), [&] { return distribution(generator); });
   return result;
 }
 
 template <class T>
 static void BM_Basic(benchmark::State& state) {

libcxx/benchmarks/function.bench.cpp

enum class FunctionType {
   MemberPointer,
   SmallTrivialFunctor,
   SmallNonTrivialFunctor,
   LargeTrivialFunctor,
   LargeNonTrivialFunctor
 };
 
 struct AllFunctionTypes : EnumValuesAsTuple<AllFunctionTypes, FunctionType, 8> {
-  static constexpr const char* Names[] = {"Null",
-                                          "FuncPtr",
-                                          "MemFuncPtr",
-                                          "MemPtr",
-                                          "SmallTrivialFunctor",
-                                          "SmallNonTrivialFunctor",
-                                          "LargeTrivialFunctor",
-                                          "LargeNonTrivialFunctor"};
+  static constexpr const char* Names[] = {
+      "Null",
 };
 
 enum class Opacity { kOpaque, kTransparent };
 
 struct AllOpacity : EnumValuesAsTuple<AllOpacity, Opacity, 2> {
   static constexpr const char* Names[] = {"Opaque", "Transparent"};
 };
 

 struct SmallNonTrivialFunctor {
   SmallNonTrivialFunctor() {}
   SmallNonTrivialFunctor(const SmallNonTrivialFunctor&) {}
   ~SmallNonTrivialFunctor() {}
   int operator()(const S*) const { return 0; }
 };
 struct LargeTrivialFunctor {
   LargeTrivialFunctor() {
-      // Do not spend time initializing the padding.
   }
   int padding[16];
   int operator()(const S*) const { return 0; }
 };
 struct LargeNonTrivialFunctor {
   int padding[16];
   LargeNonTrivialFunctor() {
-      // Do not spend time initializing the padding.
   }
   LargeNonTrivialFunctor(const LargeNonTrivialFunctor&) {}
   ~LargeNonTrivialFunctor() {}
   int operator()(const S*) const { return 0; }
 };
 
 using Function = std::function<int(const S*)>;
 
 TEST_ALWAYS_INLINE
 inline Function MakeFunction(FunctionType type, bool opaque = false) {
   switch (type) {
-    case FunctionType::Null:
-      return nullptr;
-    case FunctionType::FunctionPointer:
-      return maybeOpaque(FunctionWithS, opaque);
-    case FunctionType::MemberFunctionPointer:
-      return maybeOpaque(&S::function, opaque);
-    case FunctionType::MemberPointer:
-      return maybeOpaque(&S::field, opaque);
-    case FunctionType::SmallTrivialFunctor:
-      return maybeOpaque(SmallTrivialFunctor{}, opaque);
-    case FunctionType::SmallNonTrivialFunctor:
-      return maybeOpaque(SmallNonTrivialFunctor{}, opaque);
-    case FunctionType::LargeTrivialFunctor:
-      return maybeOpaque(LargeTrivialFunctor{}, opaque);
-    case FunctionType::LargeNonTrivialFunctor:
-      return maybeOpaque(LargeNonTrivialFunctor{}, opaque);
   }
 }
 
 template <class Opacity, class FunctionType>
 struct ConstructAndDestroy {
   static void run(benchmark::State& state) {
     for (auto _ : state) {
       if (Opacity() == ::Opacity::kOpaque) {
         benchmark::DoNotOptimize(MakeFunction(FunctionType(), true));
       } else {
         MakeFunction(FunctionType());
       }
     }
   }
 
-  static std::string name() {
-    return "BM_ConstructAndDestroy" + FunctionType::name() + Opacity::name();
-  }
+  static std::string name() { return "BM_ConstructAndDestroy" + FunctionType::name() + Opacity::name(); }
 };
 
 template <class FunctionType>
 struct Copy {
   static void run(benchmark::State& state) {
     auto value = MakeFunction(FunctionType());
     for (auto _ : state) {
       benchmark::DoNotOptimize(value);
-      auto copy = value;  // NOLINT
+      auto copy = value; // NOLINT
       benchmark::DoNotOptimize(copy);
     }
   }
 
   static std::string name() { return "BM_Copy" + FunctionType::name(); }
 };
 
 template <class FunctionType>
 struct Move {
   static void run(benchmark::State& state) {
     Function values[2] = {MakeFunction(FunctionType())};
-    int i = 0;
+    int i              = 0;
     for (auto _ : state) {
       benchmark::DoNotOptimize(values);
       benchmark::DoNotOptimize(values[i ^ 1] = std::move(values[i]));
       i ^= 1;
     }
   }
 
-  static std::string name() {
-    return "BM_Move" + FunctionType::name();
-  }
+  static std::string name() { return "BM_Move" + FunctionType::name(); }
 };
 
 template <class Function1, class Function2>
 struct Swap {
   static void run(benchmark::State& state) {
     Function values[2] = {MakeFunction(Function1()), MakeFunction(Function2())};
     for (auto _ : state) {
       benchmark::DoNotOptimize(values);
       values[0].swap(values[1]);
     }
   }
 
   static bool skip() { return Function1() > Function2(); }
 
-  static std::string name() {
-    return "BM_Swap" + Function1::name() + Function2::name();
-  }
+  static std::string name() { return "BM_Swap" + Function1::name() + Function2::name(); }
 };
 
 template <class FunctionType>
 struct OperatorBool {
   static void run(benchmark::State& state) {
     auto f = MakeFunction(FunctionType());
     for (auto _ : state) {
       benchmark::DoNotOptimize(f);
static void run(benchmark::State& state) {
     S s;
     for (auto _ : state) {
       MakeFunction(FunctionType())(&s);
     }
   }
 
   static bool skip() { return FunctionType() == ::FunctionType::Null; }
 
-  static std::string name() {
-    return "BM_InvokeInlined" + FunctionType::name();
-  }
+  static std::string name() { return "BM_InvokeInlined" + FunctionType::name(); }
 };
 
-}  // namespace
+} // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
 
-  makeCartesianProductBenchmark<ConstructAndDestroy, AllOpacity,
-                                AllFunctionTypes>();
+  makeCartesianProductBenchmark<ConstructAndDestroy, AllOpacity, AllFunctionTypes>();
   makeCartesianProductBenchmark<Copy, AllFunctionTypes>();
   makeCartesianProductBenchmark<Move, AllFunctionTypes>();
   makeCartesianProductBenchmark<Swap, AllFunctionTypes, AllFunctionTypes>();
   makeCartesianProductBenchmark<OperatorBool, AllFunctionTypes>();
   makeCartesianProductBenchmark<Invoke, AllFunctionTypes>();
   makeCartesianProductBenchmark<InvokeInlined, AllFunctionTypes>();
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/map.bench.cpp

 #include "benchmark/benchmark.h"
 #include "test_macros.h"
 
 // When VALIDATE is defined the benchmark will run to validate the benchmarks.
 // The time taken by several operations depend on whether or not an element
 // exists. To avoid errors in the benchmark these operations have a validation
 // mode to test the benchmark. Since they are not meant to be benchmarked the
 // number of sizes tested is limited to 1.
-//#define VALIDATE
+// #define VALIDATE
 
 namespace {
 
 enum class Mode { Hit, Miss };
 
 struct AllModes : EnumValuesAsTuple<AllModes, Mode, 2> {
   static constexpr const char* Names[] = {"ExistingElement", "NewElement"};
 };

 enum class Order { Sorted, Random };
 struct AllOrders : EnumValuesAsTuple<AllOrders, Order, 2> {
   static constexpr const char* Names[] = {"Sorted", "Random"};
 };
 
 struct TestSets {
   std::vector<uint64_t> Keys;
   std::vector<std::map<uint64_t, int64_t> > Maps;
-  std::vector<
-      std::vector<typename std::map<uint64_t, int64_t>::const_iterator> >
-      Hints;
+  std::vector< std::vector<typename std::map<uint64_t, int64_t>::const_iterator> > Hints;
 };
 
 enum class Shuffle { None, Keys, Hints };
 
-TestSets makeTestingSets(size_t MapSize, Mode mode, Shuffle shuffle,
-                         size_t max_maps) {
+TestSets makeTestingSets(size_t MapSize, Mode mode, Shuffle shuffle, size_t max_maps) {
   /*
    * The shuffle does not retain the random number generator to use the same
    * set of random numbers for every iteration.
    */
   TestSets R;
 
   int MapCount = std::min(max_maps, 1000000 / MapSize);
 
   for (uint64_t I = 0; I < MapSize; ++I) {
     R.Keys.push_back(mode == Mode::Hit ? 2 * I + 2 : 2 * I + 1);
   }
   if (shuffle == Shuffle::Keys)
     std::shuffle(R.Keys.begin(), R.Keys.end(), std::mt19937());
 
   for (int M = 0; M < MapCount; ++M) {
-    auto& map = R.Maps.emplace_back();
+    auto& map   = R.Maps.emplace_back();
     auto& hints = R.Hints.emplace_back();
     for (uint64_t I = 0; I < MapSize; ++I) {
       hints.push_back(map.insert(std::make_pair(2 * I + 2, 0)).first);
     }
     if (shuffle == Shuffle::Hints)
       std::shuffle(hints.begin(), hints.end(), std::mt19937());
   }
 

 struct ConstructorIterator : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode::Hit, Shuffle::None, 1);
     auto& Map = Data.Maps.front();
     while (State.KeepRunningBatch(MapSize)) {
 #ifndef VALIDATE
-      benchmark::DoNotOptimize(
-          std::map<uint64_t, int64_t>(Map.begin(), Map.end()));
+      benchmark::DoNotOptimize(std::map<uint64_t, int64_t>(Map.begin(), Map.end()));
 #else
       std::map<uint64_t, int64_t> M{Map.begin(), Map.end()};
       if (M != Map)
         State.SkipWithError("Map copy not identical");
 #endif
     }
   }
 
struct Clear : Base {
   std::string name() const { return "BM_Clear" + baseName(); }
 };
 
 template <class Mode, class Order>
 struct Insert : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (auto& Map : Data.Maps) {
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.insert(std::make_pair(K, 1)));
 #else
           bool Inserted = Map.insert(std::make_pair(K, 1)).second;
           if (Mode() == ::Mode::Hit) {
             if (Inserted)
               State.SkipWithError("Inserted a duplicate element");
           } else {
             if (!Inserted)
               State.SkipWithError("Failed to insert e new element");
           }
 #endif
         }
       }
 
       State.PauseTiming();
-      Data = makeTestingSets(MapSize, Mode(),
-                             Order::value == ::Order::Random ? Shuffle::Keys
-                                                             : Shuffle::None,
-                             1000);
+      Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
-  std::string name() const {
-    return "BM_Insert" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_Insert" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Mode, class Hint>
 struct InsertHint : Base {
   using Base::Base;
 
   template < ::Hint hint>
-  typename std::enable_if<hint == ::Hint::Correct>::type
-  run(benchmark::State& State) const {
+  typename std::enable_if<hint == ::Hint::Correct>::type run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
         auto& Map = Data.Maps[I];
-        auto H = Data.Hints[I].begin();
+        auto H    = Data.Hints[I].begin();
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.insert(*H, std::make_pair(K, 1)));
 #else
           auto Inserted = Map.insert(*H, std::make_pair(K, 1));
           if (Mode() == ::Mode::Hit) {
             if (Inserted != *H)
               State.SkipWithError("Inserted a duplicate element");
           } else {
             if (++Inserted != *H)
               State.SkipWithError("Failed to insert a new element");
           }
 #endif
           ++H;
         }
       }
 
       State.PauseTiming();
       Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
   template < ::Hint hint>
-  typename std::enable_if<hint != ::Hint::Correct>::type
-  run(benchmark::State& State) const {
+  typename std::enable_if<hint != ::Hint::Correct>::type run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
-        auto& Map = Data.Maps[I];
+        auto& Map  = Data.Maps[I];
         auto Third = *(Data.Hints[I].begin() + 2);
         for (auto K : Data.Keys) {
-          auto Itor = hint == ::Hint::Begin
-                          ? Map.begin()
-                          : hint == ::Hint::Third ? Third : Map.end();
+          auto Itor = hint == ::Hint::Begin ? Map.begin() : hint == ::Hint::Third ? Third : Map.end();
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.insert(Itor, std::make_pair(K, 1)));
 #else
           size_t Size = Map.size();
           Map.insert(Itor, std::make_pair(K, 1));
           if (Mode() == ::Mode::Hit) {
             if (Size != Map.size())
               State.SkipWithError("Inserted a duplicate element");
#endif
     }
   }
 
   void run(benchmark::State& State) const {
     static constexpr auto h = Hint();
     run<h>(State);
   }
 
-  std::string name() const {
-    return "BM_InsertHint" + baseName() + Mode::name() + Hint::name();
-  }
+  std::string name() const { return "BM_InsertHint" + baseName() + Mode::name() + Hint::name(); }
 };
 
 template <class Mode, class Order>
 struct InsertAssign : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (auto& Map : Data.Maps) {
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.insert_or_assign(K, 1));
 #else
           bool Inserted = Map.insert_or_assign(K, 1).second;
           if (Mode() == ::Mode::Hit) {
             if (Inserted)
               State.SkipWithError("Inserted a duplicate element");
           } else {
             if (!Inserted)
               State.SkipWithError("Failed to insert e new element");
           }
 #endif
         }
       }
 
       State.PauseTiming();
-      Data = makeTestingSets(MapSize, Mode(),
-                             Order::value == ::Order::Random ? Shuffle::Keys
-                                                             : Shuffle::None,
-                             1000);
+      Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
-  std::string name() const {
-    return "BM_InsertAssign" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_InsertAssign" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Mode, class Hint>
 struct InsertAssignHint : Base {
   using Base::Base;
 
   template < ::Hint hint>
-  typename std::enable_if<hint == ::Hint::Correct>::type
-  run(benchmark::State& State) const {
+  typename std::enable_if<hint == ::Hint::Correct>::type run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
         auto& Map = Data.Maps[I];
-        auto H = Data.Hints[I].begin();
+        auto H    = Data.Hints[I].begin();
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.insert_or_assign(*H, K, 1));
 #else
           auto Inserted = Map.insert_or_assign(*H, K, 1);
           if (Mode() == ::Mode::Hit) {
             if (Inserted != *H)
               State.SkipWithError("Inserted a duplicate element");
           } else {
             if (++Inserted != *H)
               State.SkipWithError("Failed to insert a new element");
           }
 #endif
           ++H;
         }
       }
 
       State.PauseTiming();
       Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
   template < ::Hint hint>
-  typename std::enable_if<hint != ::Hint::Correct>::type
-  run(benchmark::State& State) const {
+  typename std::enable_if<hint != ::Hint::Correct>::type run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
-        auto& Map = Data.Maps[I];
+        auto& Map  = Data.Maps[I];
         auto Third = *(Data.Hints[I].begin() + 2);
         for (auto K : Data.Keys) {
-          auto Itor = hint == ::Hint::Begin
-                          ? Map.begin()
-                          : hint == ::Hint::Third ? Third : Map.end();
+          auto Itor = hint == ::Hint::Begin ? Map.begin() : hint == ::Hint::Third ? Third : Map.end();
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.insert_or_assign(Itor, K, 1));
 #else
           size_t Size = Map.size();
           Map.insert_or_assign(Itor, K, 1);
           if (Mode() == ::Mode::Hit) {
             if (Size != Map.size())
               State.SkipWithError("Inserted a duplicate element");
#endif
     }
   }
 
   void run(benchmark::State& State) const {
     static constexpr auto h = Hint();
     run<h>(State);
   }
 
-  std::string name() const {
-    return "BM_InsertAssignHint" + baseName() + Mode::name() + Hint::name();
-  }
+  std::string name() const { return "BM_InsertAssignHint" + baseName() + Mode::name() + Hint::name(); }
 };
 
 template <class Mode, class Order>
 struct Emplace : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (auto& Map : Data.Maps) {
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.emplace(K, 1));
 #else
           bool Inserted = Map.emplace(K, 1).second;
           if (Mode() == ::Mode::Hit) {
             if (Inserted)
               State.SkipWithError("Emplaced a duplicate element");
           } else {
             if (!Inserted)
               State.SkipWithError("Failed to emplace a new element");
           }
 #endif
         }
       }
 
       State.PauseTiming();
-      Data = makeTestingSets(MapSize, Mode(),
-                             Order::value == ::Order::Random ? Shuffle::Keys
-                                                             : Shuffle::None,
-                             1000);
+      Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
-  std::string name() const {
-    return "BM_Emplace" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_Emplace" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Mode, class Hint>
 struct EmplaceHint : Base {
   using Base::Base;
 
   template < ::Hint hint>
-  typename std::enable_if<hint == ::Hint::Correct>::type
-  run(benchmark::State& State) const {
+  typename std::enable_if<hint == ::Hint::Correct>::type run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
         auto& Map = Data.Maps[I];
-        auto H = Data.Hints[I].begin();
+        auto H    = Data.Hints[I].begin();
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.emplace_hint(*H, K, 1));
 #else
           auto Inserted = Map.emplace_hint(*H, K, 1);
           if (Mode() == ::Mode::Hit) {
             if (Inserted != *H)
               State.SkipWithError("Emplaced a duplicate element");
           } else {
             if (++Inserted != *H)
               State.SkipWithError("Failed to emplace a new element");
           }
 #endif
           ++H;
         }
       }
 
       State.PauseTiming();
       Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
   template < ::Hint hint>
-  typename std::enable_if<hint != ::Hint::Correct>::type
-  run(benchmark::State& State) const {
+  typename std::enable_if<hint != ::Hint::Correct>::type run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
-        auto& Map = Data.Maps[I];
+        auto& Map  = Data.Maps[I];
         auto Third = *(Data.Hints[I].begin() + 2);
         for (auto K : Data.Keys) {
-          auto Itor = hint == ::Hint::Begin
-                          ? Map.begin()
-                          : hint == ::Hint::Third ? Third : Map.end();
+          auto Itor = hint == ::Hint::Begin ? Map.begin() : hint == ::Hint::Third ? Third : Map.end();
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.emplace_hint(Itor, K, 1));
 #else
           size_t Size = Map.size();
           Map.emplace_hint(Itor, K, 1);
           if (Mode() == ::Mode::Hit) {
             if (Size != Map.size())
               State.SkipWithError("Emplaced a duplicate element");
#endif
     }
   }
 
   void run(benchmark::State& State) const {
     static constexpr auto h = Hint();
     run<h>(State);
   }
 
-  std::string name() const {
-    return "BM_EmplaceHint" + baseName() + Mode::name() + Hint::name();
-  }
+  std::string name() const { return "BM_EmplaceHint" + baseName() + Mode::name() + Hint::name(); }
 };
 
 template <class Mode, class Order>
 struct TryEmplace : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (auto& Map : Data.Maps) {
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.try_emplace(K, 1));
 #else
           bool Inserted = Map.try_emplace(K, 1).second;
           if (Mode() == ::Mode::Hit) {
             if (Inserted)
               State.SkipWithError("Emplaced a duplicate element");
           } else {
             if (!Inserted)
               State.SkipWithError("Failed to emplace a new element");
           }
 #endif
         }
       }
 
       State.PauseTiming();
-      Data = makeTestingSets(MapSize, Mode(),
-                             Order::value == ::Order::Random ? Shuffle::Keys
-                                                             : Shuffle::None,
-                             1000);
+      Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
-  std::string name() const {
-    return "BM_TryEmplace" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_TryEmplace" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Mode, class Hint>
 struct TryEmplaceHint : Base {
   using Base::Base;
 
   template < ::Hint hint>
-  typename std::enable_if<hint == ::Hint::Correct>::type
-  run(benchmark::State& State) const {
+  typename std::enable_if<hint == ::Hint::Correct>::type run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
         auto& Map = Data.Maps[I];
-        auto H = Data.Hints[I].begin();
+        auto H    = Data.Hints[I].begin();
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.try_emplace(*H, K, 1));
 #else
           auto Inserted = Map.try_emplace(*H, K, 1);
           if (Mode() == ::Mode::Hit) {
             if (Inserted != *H)
               State.SkipWithError("Emplaced a duplicate element");
           } else {
             if (++Inserted != *H)
               State.SkipWithError("Failed to emplace a new element");
           }
 #endif
           ++H;
         }
       }
 
       State.PauseTiming();
       Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
   template < ::Hint hint>
-  typename std::enable_if<hint != ::Hint::Correct>::type
-  run(benchmark::State& State) const {
+  typename std::enable_if<hint != ::Hint::Correct>::type run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode(), Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
-        auto& Map = Data.Maps[I];
+        auto& Map  = Data.Maps[I];
         auto Third = *(Data.Hints[I].begin() + 2);
         for (auto K : Data.Keys) {
-          auto Itor = hint == ::Hint::Begin
-                          ? Map.begin()
-                          : hint == ::Hint::Third ? Third : Map.end();
+          auto Itor = hint == ::Hint::Begin ? Map.begin() : hint == ::Hint::Third ? Third : Map.end();
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.try_emplace(Itor, K, 1));
 #else
           size_t Size = Map.size();
           Map.try_emplace(Itor, K, 1);
           if (Mode() == ::Mode::Hit) {
             if (Size != Map.size())
               State.SkipWithError("Emplaced a duplicate element");
#endif
     }
   }
 
   void run(benchmark::State& State) const {
     static constexpr auto h = Hint();
     run<h>(State);
   }
 
-  std::string name() const {
-    return "BM_TryEmplaceHint" + baseName() + Mode::name() + Hint::name();
-  }
+  std::string name() const { return "BM_TryEmplaceHint" + baseName() + Mode::name() + Hint::name(); }
 };
 
 template <class Mode, class Order>
 struct Erase : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (auto& Map : Data.Maps) {
         for (auto K : Data.Keys) {
 #ifndef VALIDATE
           benchmark::DoNotOptimize(Map.erase(K));
 #else
           size_t I = Map.erase(K);
           if (Mode() == ::Mode::Hit) {
             if (I == 0)
               State.SkipWithError("Did not find the existing element");
           } else {
             if (I == 1)
               State.SkipWithError("Did find the non-existing element");
           }
 #endif
         }
       }
 
       State.PauseTiming();
-      Data = makeTestingSets(MapSize, Mode(),
-                             Order::value == ::Order::Random ? Shuffle::Keys
-                                                             : Shuffle::None,
-                             1000);
+      Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
-  std::string name() const {
-    return "BM_Erase" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_Erase" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Order>
 struct EraseIterator : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode::Hit,
-        Order::value == ::Order::Random ? Shuffle::Hints : Shuffle::None, 1000);
+    auto Data =
+        makeTestingSets(MapSize, Mode::Hit, Order::value == ::Order::Random ? Shuffle::Hints : Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {
       for (size_t I = 0; I < Data.Maps.size(); ++I) {
         auto& Map = Data.Maps[I];
         for (auto H : Data.Hints[I]) {
           benchmark::DoNotOptimize(Map.erase(H));
         }
 #ifdef VALIDATE
         if (!Map.empty())
           State.SkipWithError("Did not erase the entire map");
 #endif
       }
 
       State.PauseTiming();
-      Data = makeTestingSets(MapSize, Mode::Hit,
-                             Order::value == ::Order::Random ? Shuffle::Hints
-                                                             : Shuffle::None,
-                             1000);
+      Data =
+          makeTestingSets(MapSize, Mode::Hit, Order::value == ::Order::Random ? Shuffle::Hints : Shuffle::None, 1000);
       State.ResumeTiming();
     }
   }
 
-  std::string name() const {
-    return "BM_EraseIterator" + baseName() + Order::name();
-  }
+  std::string name() const { return "BM_EraseIterator" + baseName() + Order::name(); }
 };
 
 struct EraseRange : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
     auto Data = makeTestingSets(MapSize, Mode::Hit, Shuffle::None, 1000);
     while (State.KeepRunningBatch(MapSize * Data.Maps.size())) {

 //                            Lookup                                 |
 //*******************************************************************|
 
 template <class Mode, class Order>
 struct Count : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
     auto& Map = Data.Maps.front();
     while (State.KeepRunningBatch(MapSize)) {
       for (auto K : Data.Keys) {
 #ifndef VALIDATE
         benchmark::DoNotOptimize(Map.count(K));
 #else
         size_t I = Map.count(K);
         if (Mode() == ::Mode::Hit) {
           if (I == 0)
             State.SkipWithError("Did not find the existing element");
         } else {
           if (I == 1)
             State.SkipWithError("Did find the non-existing element");
         }
 #endif
       }
     }
   }
 
-  std::string name() const {
-    return "BM_Count" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_Count" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Mode, class Order>
 struct Find : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
     auto& Map = Data.Maps.front();
     while (State.KeepRunningBatch(MapSize)) {
       for (auto K : Data.Keys) {
 #ifndef VALIDATE
         benchmark::DoNotOptimize(Map.find(K));
 #else
         auto Itor = Map.find(K);
         if (Mode() == ::Mode::Hit) {
           if (Itor == Map.end())
             State.SkipWithError("Did not find the existing element");
         } else {
           if (Itor != Map.end())
             State.SkipWithError("Did find the non-existing element");
         }
 #endif
       }
     }
   }
 
-  std::string name() const {
-    return "BM_Find" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_Find" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Mode, class Order>
 struct EqualRange : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
     auto& Map = Data.Maps.front();
     while (State.KeepRunningBatch(MapSize)) {
       for (auto K : Data.Keys) {
 #ifndef VALIDATE
         benchmark::DoNotOptimize(Map.equal_range(K));
 #else
         auto Range = Map.equal_range(K);
         if (Mode() == ::Mode::Hit) {
           // Adjust validation for the last element.
           auto Key = K;
           if (Range.second == Map.end() && K == 2 * MapSize) {
             --Range.second;
             Key -= 2;
           }
-          if (Range.first == Map.end() || Range.first->first != K ||
-              Range.second == Map.end() || Range.second->first - 2 != Key)
+          if (Range.first == Map.end() || Range.first->first != K || Range.second == Map.end() ||
+              Range.second->first - 2 != Key)
             State.SkipWithError("Did not find the existing element");
         } else {
-          if (Range.first == Map.end() || Range.first->first - 1 != K ||
-              Range.second == Map.end() || Range.second->first - 1 != K)
+          if (Range.first == Map.end() || Range.first->first - 1 != K || Range.second == Map.end() ||
+              Range.second->first - 1 != K)
             State.SkipWithError("Did find the non-existing element");
         }
 #endif
       }
     }
   }
 
-  std::string name() const {
-    return "BM_EqualRange" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_EqualRange" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Mode, class Order>
 struct LowerBound : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
     auto& Map = Data.Maps.front();
     while (State.KeepRunningBatch(MapSize)) {
       for (auto K : Data.Keys) {
 #ifndef VALIDATE
         benchmark::DoNotOptimize(Map.lower_bound(K));
 #else
         auto Itor = Map.lower_bound(K);
         if (Mode() == ::Mode::Hit) {
           if (Itor == Map.end() || Itor->first != K)
             State.SkipWithError("Did not find the existing element");
         } else {
           if (Itor == Map.end() || Itor->first - 1 != K)
             State.SkipWithError("Did find the non-existing element");
         }
 #endif
       }
     }
   }
 
-  std::string name() const {
-    return "BM_LowerBound" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_LowerBound" + baseName() + Mode::name() + Order::name(); }
 };
 
 template <class Mode, class Order>
 struct UpperBound : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(
-        MapSize, Mode(),
-        Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
+    auto Data = makeTestingSets(MapSize, Mode(), Order::value == ::Order::Random ? Shuffle::Keys : Shuffle::None, 1);
     auto& Map = Data.Maps.front();
     while (State.KeepRunningBatch(MapSize)) {
       for (auto K : Data.Keys) {
 #ifndef VALIDATE
         benchmark::DoNotOptimize(Map.upper_bound(K));
 #else
         std::map<uint64_t, int64_t>::iterator Itor = Map.upper_bound(K);
         if (Mode() == ::Mode::Hit) {
#else
           if (Itor == Map.end() || Itor->first - 1 != K)
             State.SkipWithError("Did find the non-existing element");
         }
 #endif
       }
     }
   }
 
-  std::string name() const {
-    return "BM_UpperBound" + baseName() + Mode::name() + Order::name();
-  }
+  std::string name() const { return "BM_UpperBound" + baseName() + Mode::name() + Order::name(); }
 };
 
 } // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;

libcxx/benchmarks/ordered_set.bench.cpp

 enum class HitType { Hit, Miss };
 
 struct AllHitTypes : EnumValuesAsTuple<AllHitTypes, HitType, 2> {
   static constexpr const char* Names[] = {"Hit", "Miss"};
 };
 
 enum class AccessPattern { Ordered, Random };
 
-struct AllAccessPattern
-    : EnumValuesAsTuple<AllAccessPattern, AccessPattern, 2> {
+struct AllAccessPattern : EnumValuesAsTuple<AllAccessPattern, AccessPattern, 2> {
   static constexpr const char* Names[] = {"Ordered", "Random"};
 };
 
 void sortKeysBy(std::vector<uint64_t>& Keys, AccessPattern AP) {
   if (AP == AccessPattern::Random) {
     std::random_device R;
     std::mt19937 M(R());
     std::shuffle(std::begin(Keys), std::end(Keys), M);
   }
 }
 
 struct TestSets {
   std::vector<std::set<uint64_t> > Sets;
   std::vector<uint64_t> Keys;
 };
 
-TestSets makeTestingSets(size_t TableSize, size_t NumTables, HitType Hit,
-                         AccessPattern Access) {
+TestSets makeTestingSets(size_t TableSize, size_t NumTables, HitType Hit, AccessPattern Access) {
   TestSets R;
   R.Sets.resize(1);
 
   for (uint64_t I = 0; I < TableSize; ++I) {
     R.Sets[0].insert(2 * I);
     R.Keys.push_back(Hit == HitType::Hit ? 2 * I : 2 * I + 1);
   }
   R.Sets.resize(NumTables, R.Sets[0]);
   sortKeysBy(R.Keys, Access);
 
   return R;
 }
 
 struct Base {
   size_t TableSize;
   size_t NumTables;
   Base(size_t T, size_t N) : TableSize(T), NumTables(N) {}
 
   bool skip() const {
     size_t Total = TableSize * NumTables;
     return Total < 100 || Total > 1000000;
   }
 
   std::string baseName() const {
-    return "_TableSize" + std::to_string(TableSize) + "_NumTables" +
-           std::to_string(NumTables);
+    return "_TableSize" + std::to_string(TableSize) + "_NumTables" + std::to_string(NumTables);
   }
 };
 
 template <class Access>
 struct Create : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
     std::vector<uint64_t> Keys(TableSize);
     std::iota(Keys.begin(), Keys.end(), uint64_t{0});
     sortKeysBy(Keys, Access());
 
     while (State.KeepRunningBatch(TableSize * NumTables)) {
       std::vector<std::set<uint64_t>> Sets(NumTables);
       for (auto K : Keys) {
         for (auto& Set : Sets) {
           benchmark::DoNotOptimize(Set.insert(K));
         }
       }
     }
   }
 
-  std::string name() const {
-    return "BM_Create" + Access::name() + baseName();
-  }
+  std::string name() const { return "BM_Create" + Access::name() + baseName(); }
 };
 
 template <class Hit, class Access>
 struct Find : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
     auto Data = makeTestingSets(TableSize, NumTables, Hit(), Access());
 
     while (State.KeepRunningBatch(TableSize * NumTables)) {
       for (auto K : Data.Keys) {
         for (auto& Set : Data.Sets) {
           benchmark::DoNotOptimize(Set.find(K));
         }
       }
     }
   }
 
-  std::string name() const {
-    return "BM_Find" + Hit::name() + Access::name() + baseName();
-  }
+  std::string name() const { return "BM_Find" + Hit::name() + Access::name() + baseName(); }
 };
 
 template <class Hit, class Access>
 struct FindNeEnd : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
     auto Data = makeTestingSets(TableSize, NumTables, Hit(), Access());
 
     while (State.KeepRunningBatch(TableSize * NumTables)) {
       for (auto K : Data.Keys) {
         for (auto& Set : Data.Sets) {
           benchmark::DoNotOptimize(Set.find(K) != Set.end());
         }
       }
     }
   }
 
-  std::string name() const {
-    return "BM_FindNeEnd" + Hit::name() + Access::name() + baseName();
-  }
+  std::string name() const { return "BM_FindNeEnd" + Hit::name() + Access::name() + baseName(); }
 };
 
 template <class Access>
 struct InsertHit : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
     auto Data = makeTestingSets(TableSize, NumTables, HitType::Hit, Access());
 
     while (State.KeepRunningBatch(TableSize * NumTables)) {
       for (auto K : Data.Keys) {
         for (auto& Set : Data.Sets) {
           benchmark::DoNotOptimize(Set.insert(K));
         }
       }
     }
   }
 
-  std::string name() const {
-    return "BM_InsertHit" + Access::name() + baseName();
-  }
+  std::string name() const { return "BM_InsertHit" + Access::name() + baseName(); }
 };
 
 template <class Access>
 struct InsertMissAndErase : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
     auto Data = makeTestingSets(TableSize, NumTables, HitType::Miss, Access());
 
     while (State.KeepRunningBatch(TableSize * NumTables)) {
       for (auto K : Data.Keys) {
         for (auto& Set : Data.Sets) {
           benchmark::DoNotOptimize(Set.erase(Set.insert(K).first));
         }
       }
     }
   }
 
-  std::string name() const {
-    return "BM_InsertMissAndErase" + Access::name() + baseName();
-  }
+  std::string name() const { return "BM_InsertMissAndErase" + Access::name() + baseName(); }
 };
 
 struct IterateRangeFor : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(TableSize, NumTables, HitType::Miss,
-                                AccessPattern::Ordered);
+    auto Data = makeTestingSets(TableSize, NumTables, HitType::Miss, AccessPattern::Ordered);
 
     while (State.KeepRunningBatch(TableSize * NumTables)) {
       for (auto& Set : Data.Sets) {
         for (auto& V : Set) {
           benchmark::DoNotOptimize(V);
         }
       }
     }
   }
 
   std::string name() const { return "BM_IterateRangeFor" + baseName(); }
 };
 
 struct IterateBeginEnd : Base {
   using Base::Base;
 
   void run(benchmark::State& State) const {
-    auto Data = makeTestingSets(TableSize, NumTables, HitType::Miss,
-                                AccessPattern::Ordered);
+    auto Data = makeTestingSets(TableSize, NumTables, HitType::Miss, AccessPattern::Ordered);
 
     while (State.KeepRunningBatch(TableSize * NumTables)) {
       for (auto& Set : Data.Sets) {
         for (auto it = Set.begin(); it != Set.end(); ++it) {
           benchmark::DoNotOptimize(*it);
         }
       }
     }
   }
 
   std::string name() const { return "BM_IterateBeginEnd" + baseName(); }
 };
 
-}  // namespace
+} // namespace
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
 
   const std::vector<size_t> TableSize{1, 10, 100, 1000, 10000, 100000, 1000000};
   const std::vector<size_t> NumTables{1, 10, 100, 1000, 10000, 100000, 1000000};
 
   makeCartesianProductBenchmark<Create, AllAccessPattern>(TableSize, NumTables);
-  makeCartesianProductBenchmark<Find, AllHitTypes, AllAccessPattern>(
-      TableSize, NumTables);
-  makeCartesianProductBenchmark<FindNeEnd, AllHitTypes, AllAccessPattern>(
-      TableSize, NumTables);
-  makeCartesianProductBenchmark<InsertHit, AllAccessPattern>(
-      TableSize, NumTables);
-  makeCartesianProductBenchmark<InsertMissAndErase, AllAccessPattern>(
-      TableSize, NumTables);
+  makeCartesianProductBenchmark<Find, AllHitTypes, AllAccessPattern>(TableSize, NumTables);
+  makeCartesianProductBenchmark<FindNeEnd, AllHitTypes, AllAccessPattern>(TableSize, NumTables);
+  makeCartesianProductBenchmark<InsertHit, AllAccessPattern>(TableSize, NumTables);
+  makeCartesianProductBenchmark<InsertMissAndErase, AllAccessPattern>(TableSize, NumTables);
   makeCartesianProductBenchmark<IterateRangeFor>(TableSize, NumTables);
   makeCartesianProductBenchmark<IterateBeginEnd>(TableSize, NumTables);
   benchmark::RunSpecifiedBenchmarks();
 }

libcxx/benchmarks/random.bench.cpp

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <array>
 #include <cstddef>
 #include <functional>
 #include <random>
 
 #include "benchmark/benchmark.h"
 
 constexpr std::size_t MAX_BUFFER_LEN = 256;
-constexpr std::size_t MAX_SEED_LEN = 16;
+constexpr std::size_t MAX_SEED_LEN   = 16;
 
 static void BM_SeedSeq_Generate(benchmark::State& state) {
   std::array<std::uint32_t, MAX_BUFFER_LEN> buffer;
   std::array<std::uint32_t, MAX_SEED_LEN> seeds;
   {
     std::random_device rd;
     std::generate(std::begin(seeds), std::begin(seeds) + state.range(0), [&]() { return rd(); });
   }
   std::seed_seq seed(std::begin(seeds), std::begin(seeds) + state.range(0));
   for (auto _ : state) {
     seed.generate(std::begin(buffer), std::begin(buffer) + state.range(1));
   }
 }
 BENCHMARK(BM_SeedSeq_Generate)->Ranges({{1, MAX_SEED_LEN}, {1, MAX_BUFFER_LEN}});
 
 BENCHMARK_MAIN();

libcxx/benchmarks/string.bench.cpp

 
 #include <cstdint>
 #include <new>
 #include <vector>
 
 #include "CartesianBenchmarks.h"
 #include "GenerateInput.h"
 #include "benchmark/benchmark.h"
 #include "test_macros.h"
 
 constexpr std::size_t MAX_STRING_LEN = 8 << 14;
 
 // Benchmark when there is no match.
-static void BM_StringFindNoMatch(benchmark::State &state) {
+static void BM_StringFindNoMatch(benchmark::State& state) {
   std::string s1(state.range(0), '-');
   std::string s2(8, '*');
   for (auto _ : state)
     benchmark::DoNotOptimize(s1.find(s2));
 }
 BENCHMARK(BM_StringFindNoMatch)->Range(10, MAX_STRING_LEN);
 
 // Benchmark when the string matches first time.
-static void BM_StringFindAllMatch(benchmark::State &state) {
+static void BM_StringFindAllMatch(benchmark::State& state) {
   std::string s1(MAX_STRING_LEN, '-');
   std::string s2(state.range(0), '-');
   for (auto _ : state)
     benchmark::DoNotOptimize(s1.find(s2));
 }
 BENCHMARK(BM_StringFindAllMatch)->Range(1, MAX_STRING_LEN);
 
 // Benchmark when the string matches somewhere in the end.
-static void BM_StringFindMatch1(benchmark::State &state) {
+static void BM_StringFindMatch1(benchmark::State& state) {
   std::string s1(MAX_STRING_LEN / 2, '*');
   s1 += std::string(state.range(0), '-');
   std::string s2(state.range(0), '-');
   for (auto _ : state)
     benchmark::DoNotOptimize(s1.find(s2));
 }
 BENCHMARK(BM_StringFindMatch1)->Range(1, MAX_STRING_LEN / 4);
 
 // Benchmark when the string matches somewhere from middle to the end.
-static void BM_StringFindMatch2(benchmark::State &state) {
+static void BM_StringFindMatch2(benchmark::State& state) {
   std::string s1(MAX_STRING_LEN / 2, '*');
   s1 += std::string(state.range(0), '-');
   s1 += std::string(state.range(0), '*');
   std::string s2(state.range(0), '-');
   for (auto _ : state)
     benchmark::DoNotOptimize(s1.find(s2));
 }
 BENCHMARK(BM_StringFindMatch2)->Range(1, MAX_STRING_LEN / 4);
 
-static void BM_StringCtorDefault(benchmark::State &state) {
+static void BM_StringCtorDefault(benchmark::State& state) {
   for (auto _ : state) {
     std::string Default;
     benchmark::DoNotOptimize(Default);
   }
 }
 BENCHMARK(BM_StringCtorDefault);
 
 enum class Length { Empty, Small, Large, Huge };
 struct AllLengths : EnumValuesAsTuple<AllLengths, Length, 4> {
   static constexpr const char* Names[] = {"Empty", "Small", "Large", "Huge"};
 };
 
 enum class Opacity { Opaque, Transparent };
 struct AllOpacity : EnumValuesAsTuple<AllOpacity, Opacity, 2> {
   static constexpr const char* Names[] = {"Opaque", "Transparent"};
 };
 
 enum class DiffType { Control, ChangeFirst, ChangeMiddle, ChangeLast };
 struct AllDiffTypes : EnumValuesAsTuple<AllDiffTypes, DiffType, 4> {
-  static constexpr const char* Names[] = {"Control", "ChangeFirst",
-                                          "ChangeMiddle", "ChangeLast"};
+  static constexpr const char* Names[] = {"Control", "ChangeFirst", "ChangeMiddle", "ChangeLast"};
 };
 
 static constexpr char SmallStringLiteral[] = "012345678";
 
 TEST_ALWAYS_INLINE const char* getSmallString(DiffType D) {
   switch (D) {
-    case DiffType::Control:
-      return SmallStringLiteral;
-    case DiffType::ChangeFirst:
-      return "-12345678";
-    case DiffType::ChangeMiddle:
-      return "0123-5678";
-    case DiffType::ChangeLast:
-      return "01234567-";
   }
 }
 
-static constexpr char LargeStringLiteral[] =
-    "012345678901234567890123456789012345678901234567890123456789012";
+static constexpr char LargeStringLiteral[] = "012345678901234567890123456789012345678901234567890123456789012";
 
 TEST_ALWAYS_INLINE const char* getLargeString(DiffType D) {
 #define LARGE_STRING_FIRST "123456789012345678901234567890"
 #define LARGE_STRING_SECOND "234567890123456789012345678901"
   switch (D) {
-    case DiffType::Control:
-      return "0" LARGE_STRING_FIRST "1" LARGE_STRING_SECOND "2";
-    case DiffType::ChangeFirst:
-      return "-" LARGE_STRING_FIRST "1" LARGE_STRING_SECOND "2";
-    case DiffType::ChangeMiddle:
-      return "0" LARGE_STRING_FIRST "-" LARGE_STRING_SECOND "2";
-    case DiffType::ChangeLast:
-      return "0" LARGE_STRING_FIRST "1" LARGE_STRING_SECOND "-";
   }
 }
 
 TEST_ALWAYS_INLINE const char* getHugeString(DiffType D) {
 #define HUGE_STRING0 "0123456789"
 #define HUGE_STRING1 HUGE_STRING0 HUGE_STRING0 HUGE_STRING0 HUGE_STRING0
 #define HUGE_STRING2 HUGE_STRING1 HUGE_STRING1 HUGE_STRING1 HUGE_STRING1
 #define HUGE_STRING3 HUGE_STRING2 HUGE_STRING2 HUGE_STRING2 HUGE_STRING2
 #define HUGE_STRING4 HUGE_STRING3 HUGE_STRING3 HUGE_STRING3 HUGE_STRING3
   switch (D) {
-    case DiffType::Control:
-      return "0123456789" HUGE_STRING4 "0123456789" HUGE_STRING4 "0123456789";
-    case DiffType::ChangeFirst:
-      return "-123456789" HUGE_STRING4 "0123456789" HUGE_STRING4 "0123456789";
-    case DiffType::ChangeMiddle:
-      return "0123456789" HUGE_STRING4 "01234-6789" HUGE_STRING4 "0123456789";
-    case DiffType::ChangeLast:
-      return "0123456789" HUGE_STRING4 "0123456789" HUGE_STRING4 "012345678-";
   }
 }
 
-TEST_ALWAYS_INLINE const char* getString(Length L,
-                                         DiffType D = DiffType::Control) {
+TEST_ALWAYS_INLINE const char* getString(Length L, DiffType D = DiffType::Control) {
   switch (L) {
   case Length::Empty:
     return "";
   case Length::Small:
     return getSmallString(D);
   case Length::Large:
     return getLargeString(D);
   case Length::Huge:
     return getHugeString(D);
   }
 }
 
-TEST_ALWAYS_INLINE std::string makeString(Length L,
-                                          DiffType D = DiffType::Control,
-                                          Opacity O = Opacity::Transparent) {
+TEST_ALWAYS_INLINE std::string makeString(Length L, DiffType D = DiffType::Control, Opacity O = Opacity::Transparent) {
   switch (L) {
   case Length::Empty:
     return maybeOpaque("", O == Opacity::Opaque);
   case Length::Small:
     return maybeOpaque(getSmallString(D), O == Opacity::Opaque);
   case Length::Large:
     return maybeOpaque(getLargeString(D), O == Opacity::Opaque);
   case Length::Huge:
     return maybeOpaque(getHugeString(D), O == Opacity::Opaque);
   }
 }
 
 template <class Length, class Opaque>
 struct StringConstructDestroyCStr {
   static void run(benchmark::State& state) {
     for (auto _ : state) {
-      benchmark::DoNotOptimize(
-          makeString(Length(), DiffType::Control, Opaque()));
+      benchmark::DoNotOptimize(makeString(Length(), DiffType::Control, Opaque()));
     }
   }
 
-  static std::string name() {
-    return "BM_StringConstructDestroyCStr" + Length::name() + Opaque::name();
-  }
+  static std::string name() { return "BM_StringConstructDestroyCStr" + Length::name() + Opaque::name(); }
 };
 
 template <class Length, bool MeasureCopy, bool MeasureDestroy>
 static void StringCopyAndDestroy(benchmark::State& state) {
   static constexpr size_t NumStrings = 1024;
-  auto Orig = makeString(Length());
+  auto Orig                          = makeString(Length());
   std::aligned_storage<sizeof(std::string)>::type Storage[NumStrings];
 
   while (state.KeepRunningBatch(NumStrings)) {
     if (!MeasureCopy)
       state.PauseTiming();
     for (size_t I = 0; I < NumStrings; ++I) {
       ::new (static_cast<void*>(Storage + I)) std::string(Orig);
     }
     if (!MeasureCopy)
       state.ResumeTiming();
     if (!MeasureDestroy)
       state.PauseTiming();
     for (size_t I = 0; I < NumStrings; ++I) {
       using S = std::string;
       reinterpret_cast<S*>(Storage + I)->~S();
     }
     if (!MeasureDestroy)
       state.ResumeTiming();
   }
 }
 
 template <class Length>
 struct StringCopy {
-  static void run(benchmark::State& state) {
-    StringCopyAndDestroy<Length, true, false>(state);
-  }
+  static void run(benchmark::State& state) { StringCopyAndDestroy<Length, true, false>(state); }
 
   static std::string name() { return "BM_StringCopy" + Length::name(); }
 };
 
 template <class Length>
 struct StringDestroy {
-  static void run(benchmark::State& state) {
-    StringCopyAndDestroy<Length, false, true>(state);
-  }
+  static void run(benchmark::State& state) { StringCopyAndDestroy<Length, false, true>(state); }
 
   static std::string name() { return "BM_StringDestroy" + Length::name(); }
 };
 
 template <class Length>
 struct StringMove {
   static void run(benchmark::State& state) {
     // Keep two object locations and move construct back and forth.
     std::aligned_storage<sizeof(std::string), alignof(std::string)>::type Storage[2];
-    using S = std::string;
+    using S  = std::string;
     size_t I = 0;
-    S *newS = new (static_cast<void*>(Storage)) std::string(makeString(Length()));
+    S* newS  = new (static_cast<void*>(Storage)) std::string(makeString(Length()));
     for (auto _ : state) {
       // Switch locations.
       I ^= 1;
       benchmark::DoNotOptimize(Storage);
       // Move construct into the new location,
-      S *tmpS = new (static_cast<void*>(Storage + I)) S(std::move(*newS));
+      S* tmpS = new (static_cast<void*>(Storage + I)) S(std::move(*newS));
       // then destroy the old one.
       newS->~S();
       newS = tmpS;
     }
     newS->~S();
   }
 
   static std::string name() { return "BM_StringMove" + Length::name(); }
 };
 
 template <class Length, class Opaque>
 struct StringResizeDefaultInit {
   static void run(benchmark::State& state) {
-    constexpr bool opaque = Opaque{} == Opacity::Opaque;
+    constexpr bool opaque     = Opaque{} == Opacity::Opaque;
     constexpr int kNumStrings = 4 << 10;
-    size_t length = makeString(Length()).size();
+    size_t length             = makeString(Length()).size();
     std::string strings[kNumStrings];
     while (state.KeepRunningBatch(kNumStrings)) {
       state.PauseTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         std::string().swap(strings[i]);
       }
       benchmark::DoNotOptimize(strings);
       state.ResumeTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         strings[i].__resize_default_init(maybeOpaque(length, opaque));
       }
     }
   }
 
-  static std::string name() {
-    return "BM_StringResizeDefaultInit" + Length::name() + Opaque::name();
-  }
+  static std::string name() { return "BM_StringResizeDefaultInit" + Length::name() + Opaque::name(); }
 };
 
 template <class Length, class Opaque>
 struct StringAssignStr {
   static void run(benchmark::State& state) {
-    constexpr bool opaque = Opaque{} == Opacity::Opaque;
+    constexpr bool opaque     = Opaque{} == Opacity::Opaque;
     constexpr int kNumStrings = 4 << 10;
-    std::string src = makeString(Length());
+    std::string src           = makeString(Length());
     std::string strings[kNumStrings];
     while (state.KeepRunningBatch(kNumStrings)) {
       state.PauseTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         std::string().swap(strings[i]);
       }
       benchmark::DoNotOptimize(strings);
       state.ResumeTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         strings[i] = *maybeOpaque(&src, opaque);
       }
     }
   }
 
-  static std::string name() {
-    return "BM_StringAssignStr" + Length::name() + Opaque::name();
-  }
+  static std::string name() { return "BM_StringAssignStr" + Length::name() + Opaque::name(); }
 };
 
 template <class Length, class Opaque>
 struct StringAssignAsciiz {
   static void run(benchmark::State& state) {
-    constexpr bool opaque = Opaque{} == Opacity::Opaque;
+    constexpr bool opaque     = Opaque{} == Opacity::Opaque;
     constexpr int kNumStrings = 4 << 10;
     std::string strings[kNumStrings];
     while (state.KeepRunningBatch(kNumStrings)) {
       state.PauseTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         std::string().swap(strings[i]);
       }
       benchmark::DoNotOptimize(strings);
       state.ResumeTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         strings[i] = maybeOpaque(getString(Length()), opaque);
       }
     }
   }
 
-  static std::string name() {
-    return "BM_StringAssignAsciiz" + Length::name() + Opaque::name();
-  }
+  static std::string name() { return "BM_StringAssignAsciiz" + Length::name() + Opaque::name(); }
 };
 
 template <class Length, class Opaque>
 struct StringEraseToEnd {
   static void run(benchmark::State& state) {
-    constexpr bool opaque = Opaque{} == Opacity::Opaque;
+    constexpr bool opaque     = Opaque{} == Opacity::Opaque;
     constexpr int kNumStrings = 4 << 10;
     std::string strings[kNumStrings];
     const int mid = makeString(Length()).size() / 2;
     while (state.KeepRunningBatch(kNumStrings)) {
       state.PauseTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         strings[i] = makeString(Length());
       }
       benchmark::DoNotOptimize(strings);
       state.ResumeTiming();
       for (int i = 0; i < kNumStrings; ++i) {
-        strings[i].erase(maybeOpaque(mid, opaque),
-                         maybeOpaque(std::string::npos, opaque));
+        strings[i].erase(maybeOpaque(mid, opaque), maybeOpaque(std::string::npos, opaque));
       }
     }
   }
 
-  static std::string name() {
-    return "BM_StringEraseToEnd" + Length::name() + Opaque::name();
-  }
+  static std::string name() { return "BM_StringEraseToEnd" + Length::name() + Opaque::name(); }
 };
 
 template <class Length, class Opaque>
 struct StringEraseWithMove {
   static void run(benchmark::State& state) {
-    constexpr bool opaque = Opaque{} == Opacity::Opaque;
+    constexpr bool opaque     = Opaque{} == Opacity::Opaque;
     constexpr int kNumStrings = 4 << 10;
     std::string strings[kNumStrings];
-    const int n = makeString(Length()).size() / 2;
+    const int n   = makeString(Length()).size() / 2;
     const int pos = n / 2;
     while (state.KeepRunningBatch(kNumStrings)) {
       state.PauseTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         strings[i] = makeString(Length());
       }
       benchmark::DoNotOptimize(strings);
       state.ResumeTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         strings[i].erase(maybeOpaque(pos, opaque), maybeOpaque(n, opaque));
       }
     }
   }
 
-  static std::string name() {
-    return "BM_StringEraseWithMove" + Length::name() + Opaque::name();
-  }
+  static std::string name() { return "BM_StringEraseWithMove" + Length::name() + Opaque::name(); }
 };
 
 template <class Opaque>
 struct StringAssignAsciizMix {
   static void run(benchmark::State& state) {
-    constexpr auto O = Opaque{};
-    constexpr auto D = DiffType::Control;
+    constexpr auto O          = Opaque{};
+    constexpr auto D          = DiffType::Control;
     constexpr int kNumStrings = 4 << 10;
     std::string strings[kNumStrings];
     while (state.KeepRunningBatch(kNumStrings)) {
       state.PauseTiming();
       for (int i = 0; i < kNumStrings; ++i) {
         std::string().swap(strings[i]);
       }
       benchmark::DoNotOptimize(strings);
       state.ResumeTiming();
       for (int i = 0; i < kNumStrings - 7; i += 8) {
         strings[i + 0] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
         strings[i + 1] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
         strings[i + 2] = maybeOpaque(getLargeString(D), O == Opacity::Opaque);
         strings[i + 3] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
         strings[i + 4] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
         strings[i + 5] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
         strings[i + 6] = maybeOpaque(getLargeString(D), O == Opacity::Opaque);
         strings[i + 7] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
       }
     }
   }
 
-  static std::string name() {
-    return "BM_StringAssignAsciizMix" + Opaque::name();
-  }
+  static std::string name() { return "BM_StringAssignAsciizMix" + Opaque::name(); }
 };
 
 enum class Relation { Eq, Less, Compare };
 struct AllRelations : EnumValuesAsTuple<AllRelations, Relation, 3> {
   static constexpr const char* Names[] = {"Eq", "Less", "Compare"};
 };
 
 template <class Rel, class LHLength, class RHLength, class DiffType>
if (LHLength() != RHLength() && DiffType() != ::DiffType::Control)
       return true;
     // For empty, only control matters.
     if (LHLength() == Length::Empty && DiffType() != ::DiffType::Control)
       return true;
     return false;
   }
 
   static std::string name() {
-    return "BM_StringRelational" + Rel::name() + LHLength::name() +
-           RHLength::name() + DiffType::name();
+    return "BM_StringRelational" + Rel::name() + LHLength::name() + RHLength::name() + DiffType::name();
   }
 };
 
 template <class Rel, class LHLength, class RHLength, class DiffType>
 struct StringRelationalLiteral {
   static void run(benchmark::State& state) {
     auto Lhs = makeString(LHLength(), DiffType());
     for (auto _ : state) {
       benchmark::DoNotOptimize(Lhs);
-      constexpr const char* Literal = RHLength::value == Length::Empty
-                                          ? ""
-                                          : RHLength::value == Length::Small
-                                                ? SmallStringLiteral
-                                                : LargeStringLiteral;
+      constexpr const char* Literal =
+          RHLength::value == Length::Empty ? ""
       switch (Rel()) {
       case Relation::Eq:
         benchmark::DoNotOptimize(Lhs == Literal);
         break;
       case Relation::Less:
         benchmark::DoNotOptimize(Lhs < Literal);
         break;
       case Relation::Compare:
if (LHLength() != RHLength() && DiffType() != ::DiffType::Control)
       return true;
     // We don't need huge. Doensn't give anything different than Large.
     if (LHLength() == Length::Huge || RHLength() == Length::Huge)
       return true;
     return false;
   }
 
   static std::string name() {
-    return "BM_StringRelationalLiteral" + Rel::name() + LHLength::name() +
-           RHLength::name() + DiffType::name();
+    return "BM_StringRelationalLiteral" + Rel::name() + LHLength::name() + RHLength::name() + DiffType::name();
   }
 };
 
 enum class Depth { Shallow, Deep };
 struct AllDepths : EnumValuesAsTuple<AllDepths, Depth, 2> {
   static constexpr const char* Names[] = {"Shallow", "Deep"};
 };
 
 enum class Temperature { Hot, Cold };
 struct AllTemperatures : EnumValuesAsTuple<AllTemperatures, Temperature, 2> {
   static constexpr const char* Names[] = {"Hot", "Cold"};
 };
 
 template <class Temperature, class Depth, class Length>
 struct StringRead {
   void run(benchmark::State& state) const {
     static constexpr size_t NumStrings =
-        Temperature() == ::Temperature::Hot
-            ? 1 << 10
-            : /* Enough strings to overflow the cache */ 1 << 20;
-    static_assert((NumStrings & (NumStrings - 1)) == 0,
-                  "NumStrings should be a power of two to reduce overhead.");
+        Temperature() == ::Temperature::Hot ? 1 << 10 : /* Enough strings to overflow the cache */ 1 << 20;
+    static_assert((NumStrings & (NumStrings - 1)) == 0, "NumStrings should be a power of two to reduce overhead.");
 
     std::vector<std::string> Values(NumStrings, makeString(Length()));
     size_t I = 0;
     for (auto _ : state) {
       // Jump long enough to defeat cache locality, and use a value that is
       // coprime with NumStrings to ensure we visit every element.
-      I = (I + 17) % NumStrings;
+      I             = (I + 17) % NumStrings;
       const auto& V = Values[I];
 
       // Read everything first. Escaping data() through DoNotOptimize might
       // cause the compiler to have to recalculate information about `V` due to
       // aliasing.
       const char* const Data = V.data();
-      const size_t Size = V.size();
+      const size_t Size      = V.size();
       benchmark::DoNotOptimize(Data);
       benchmark::DoNotOptimize(Size);
       if (Depth() == ::Depth::Deep) {
         // Read into the payload. This mainly shows the benefit of SSO when the
         // data is cold.
         benchmark::DoNotOptimize(*Data);
       }
     }
   }
 
   static bool skip() {
     // Huge does not give us anything that Large doesn't have. Skip it.
     if (Length() == ::Length::Huge) {
       return true;
     }
     return false;
   }
 
-  std::string name() const {
-    return "BM_StringRead" + Temperature::name() + Depth::name() +
-           Length::name();
-  }
+  std::string name() const { return "BM_StringRead" + Temperature::name() + Depth::name() + Length::name(); }
 };
 
 void sanityCheckGeneratedStrings() {
   for (auto Lhs : {Length::Empty, Length::Small, Length::Large, Length::Huge}) {
     const auto LhsString = makeString(Lhs);
-    for (auto Rhs :
-         {Length::Empty, Length::Small, Length::Large, Length::Huge}) {
+    for (auto Rhs : {Length::Empty, Length::Small, Length::Large, Length::Huge}) {
       if (Lhs > Rhs)
         continue;
       const auto RhsString = makeString(Rhs);
 
       // The smaller one must be a prefix of the larger one.
       if (RhsString.find(LhsString) != 0) {
-        fprintf(stderr, "Invalid autogenerated strings for sizes (%d,%d).\n",
-                static_cast<int>(Lhs), static_cast<int>(Rhs));
+        fprintf(
+            stderr, "Invalid autogenerated strings for sizes (%d,%d).\n", static_cast<int>(Lhs), static_cast<int>(Rhs));
         std::abort();
       }
     }
   }
   // Verify the autogenerated diffs
   for (auto L : {Length::Small, Length::Large, Length::Huge}) {
     const auto Control = makeString(L);
-    const auto Verify = [&](std::string Exp, size_t Pos) {
+    const auto Verify  = [&](std::string Exp, size_t Pos) {
       // Only change on the Pos char.
       if (Control[Pos] != Exp[Pos]) {
         Exp[Pos] = Control[Pos];
         if (Control == Exp)
           return;
       }
-      fprintf(stderr, "Invalid autogenerated diff with size %d\n",
-              static_cast<int>(L));
+      fprintf(stderr, "Invalid autogenerated diff with size %d\n", static_cast<int>(L));
       std::abort();
     };
     Verify(makeString(L, DiffType::ChangeFirst), 0);
     Verify(makeString(L, DiffType::ChangeMiddle), Control.size() / 2);
     Verify(makeString(L, DiffType::ChangeLast), Control.size() - 1);
   }
 }
 
 // Some small codegen thunks to easily see generated code.
-bool StringEqString(const std::string& a, const std::string& b) {
-  return a == b;
-}
+bool StringEqString(const std::string& a, const std::string& b) { return a == b; }
 bool StringEqCStr(const std::string& a, const char* b) { return a == b; }
 bool CStrEqString(const char* a, const std::string& b) { return a == b; }
-bool StringEqCStrLiteralEmpty(const std::string& a) {
-  return a == "";
-}
-bool StringEqCStrLiteralSmall(const std::string& a) {
-  return a == SmallStringLiteral;
-}
-bool StringEqCStrLiteralLarge(const std::string& a) {
-  return a == LargeStringLiteral;
-}
+bool StringEqCStrLiteralEmpty(const std::string& a) { return a == ""; }
+bool StringEqCStrLiteralSmall(const std::string& a) { return a == SmallStringLiteral; }
+bool StringEqCStrLiteralLarge(const std::string& a) { return a == LargeStringLiteral; }
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
 
   sanityCheckGeneratedStrings();
 
-  makeCartesianProductBenchmark<StringConstructDestroyCStr, AllLengths,
-                                AllOpacity>();
+  makeCartesianProductBenchmark<StringConstructDestroyCStr, AllLengths, AllOpacity>();
 
   makeCartesianProductBenchmark<StringAssignStr, AllLengths, AllOpacity>();
   makeCartesianProductBenchmark<StringAssignAsciiz, AllLengths, AllOpacity>();
   makeCartesianProductBenchmark<StringAssignAsciizMix, AllOpacity>();
 
   makeCartesianProductBenchmark<StringCopy, AllLengths>();
   makeCartesianProductBenchmark<StringMove, AllLengths>();
   makeCartesianProductBenchmark<StringDestroy, AllLengths>();
-  makeCartesianProductBenchmark<StringResizeDefaultInit, AllLengths,
-                                AllOpacity>();
+  makeCartesianProductBenchmark<StringResizeDefaultInit, AllLengths, AllOpacity>();
   makeCartesianProductBenchmark<StringEraseToEnd, AllLengths, AllOpacity>();
   makeCartesianProductBenchmark<StringEraseWithMove, AllLengths, AllOpacity>();
-  makeCartesianProductBenchmark<StringRelational, AllRelations, AllLengths,
-                                AllLengths, AllDiffTypes>();
-  makeCartesianProductBenchmark<StringRelationalLiteral, AllRelations,
-                                AllLengths, AllLengths, AllDiffTypes>();
-  makeCartesianProductBenchmark<StringRead, AllTemperatures, AllDepths,
-                                AllLengths>();
+  makeCartesianProductBenchmark<StringRelational, AllRelations, AllLengths, AllLengths, AllDiffTypes>();
+  makeCartesianProductBenchmark<StringRelationalLiteral, AllRelations, AllLengths, AllLengths, AllDiffTypes>();
+  makeCartesianProductBenchmark<StringRead, AllTemperatures, AllDepths, AllLengths>();
   benchmark::RunSpecifiedBenchmarks();
 
   if (argc < 0) {
     // ODR-use the functions to force them being generated in the binary.
     auto functions = std::make_tuple(
-        StringEqString, StringEqCStr, CStrEqString, StringEqCStrLiteralEmpty,
-        StringEqCStrLiteralSmall, StringEqCStrLiteralLarge);
+        StringEqString,
+        StringEqCStr,
+        CStrEqString,
+        StringEqCStrLiteralEmpty,
+        StringEqCStrLiteralSmall,
+        StringEqCStrLiteralLarge);
     printf("%p", &functions);
   }
 }

libcxx/benchmarks/stringstream.bench.cpp

 #include "benchmark/benchmark.h"
 #include "test_macros.h"
 
 #include <sstream>
 
 TEST_NOINLINE double istream_numbers();
 
 double istream_numbers() {
-  const char *a[] = {
-    "-6  69 -71  2.4882e-02 -100 101 -2.00005 5000000 -50000000",
+  const char* a[] = {"-6  69 -71  2.4882e-02 -100 101 -2.00005 5000000 -50000000",
                      "-25 71   7 -9.3262e+01 -100 101 -2.00005 5000000 -50000000",
-    "-14 53  46 -6.7026e-02 -100 101 -2.00005 5000000 -50000000"
-  };
+                     "-14 53  46 -6.7026e-02 -100 101 -2.00005 5000000 -50000000"};
 
   int a1, a2, a3, a4, a5, a6, a7;
   double f1 = 0.0, f2 = 0.0, q = 0.0;
-  for (int i=0; i < 3; i++) {
+  for (int i = 0; i < 3; i++) {
     std::istringstream s(a[i]);
-    s >> a1
-      >> a2
-      >> a3
-      >> f1
-      >> a4
-      >> a5
-      >> f2
-      >> a6
-      >> a7;
-    q += (a1 + a2 + a3 + a4 + a5 + a6 + a7 + f1 + f2)/1000000;
+    s >> a1 >> a2 >> a3 >> f1 >> a4 >> a5 >> f2 >> a6 >> a7;
+    q += (a1 + a2 + a3 + a4 + a5 + a6 + a7 + f1 + f2) / 1000000;
   }
   return q;
 }
 
-static void BM_Istream_numbers(benchmark::State &state) {
+static void BM_Istream_numbers(benchmark::State& state) {
   double i = 0;
   while (state.KeepRunning())
     benchmark::DoNotOptimize(i += istream_numbers());
 }
 
 BENCHMARK(BM_Istream_numbers)->RangeMultiplier(2)->Range(1024, 4096);
 BENCHMARK_MAIN();

libcxx/benchmarks/unordered_set_operations.bench.cpp

-#include <unordered_set>
-#include <vector>
-#include <functional>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
+#include <functional>
+#include <unordered_set>
+#include <vector>
 
 #include "benchmark/benchmark.h"
 
 #include "ContainerBenchmarks.h"
 #include "GenerateInput.h"
 #include "test_macros.h"
 
 using namespace ContainerBenchmarks;
 
 constexpr std::size_t TestNumInputs = 1024;
 
 template <class _Size>
-inline TEST_ALWAYS_INLINE
-_Size loadword(const void* __p) {
-    _Size __r;
-    std::memcpy(&__r, __p, sizeof(__r));
-    return __r;
+inline TEST_ALWAYS_INLINE _Size loadword(const void* __p) {
 }
 
-inline TEST_ALWAYS_INLINE
-std::size_t rotate_by_at_least_1(std::size_t __val, int __shift) {
-    return (__val >> __shift) | (__val << (64 - __shift));
+inline TEST_ALWAYS_INLINE std::size_t rotate_by_at_least_1(std::size_t __val, int __shift) {
 }
 
-inline TEST_ALWAYS_INLINE
-std::size_t hash_len_16(std::size_t __u, std::size_t __v) {
-    const  std::size_t __mul = 0x9ddfea08eb382d69ULL;
-    std::size_t __a = (__u ^ __v) * __mul;
-    __a ^= (__a >> 47);
-    std::size_t __b = (__v ^ __a) * __mul;
-    __b ^= (__b >> 47);
-    __b *= __mul;
-    return __b;
+inline TEST_ALWAYS_INLINE std::size_t hash_len_16(std::size_t __u, std::size_t __v) {
+  const std::size_t __mul = 0x9ddfea08eb382d69ULL;
+  std::size_t __a         = (__u ^ __v) * __mul;
 }
 
-
 template <std::size_t _Len>
-inline TEST_ALWAYS_INLINE
-std::size_t hash_len_0_to_8(const char* __s) {
-    static_assert(_Len == 4 || _Len == 8, "");
-    const uint64_t __a = loadword<uint32_t>(__s);
-    const uint64_t __b = loadword<uint32_t>(__s + _Len - 4);
-    return hash_len_16(_Len + (__a << 3), __b);
+inline TEST_ALWAYS_INLINE std::size_t hash_len_0_to_8(const char* __s) {
 }
 
 struct UInt32Hash {
   UInt32Hash() = default;
-  inline TEST_ALWAYS_INLINE
-  std::size_t operator()(uint32_t data) const {
-      return hash_len_0_to_8<4>(reinterpret_cast<const char*>(&data));
+  inline TEST_ALWAYS_INLINE std::size_t operator()(uint32_t data) const {
   }
 };
 
 struct UInt64Hash {
   UInt64Hash() = default;
-  inline TEST_ALWAYS_INLINE
-  std::size_t operator()(uint64_t data) const {
-      return hash_len_0_to_8<8>(reinterpret_cast<const char*>(&data));
+  inline TEST_ALWAYS_INLINE std::size_t operator()(uint64_t data) const {
   }
 };
 
 struct UInt128Hash {
   UInt128Hash() = default;
-  inline TEST_ALWAYS_INLINE
-  std::size_t operator()(__uint128_t data) const {
-      const __uint128_t __mask = static_cast<std::size_t>(-1);
-      const std::size_t __a = (std::size_t)(data & __mask);
-      const std::size_t __b = (std::size_t)((data & (__mask << 64)) >> 64);
-      return hash_len_16(__a, rotate_by_at_least_1(__b + 16, 16)) ^ __b;
+  inline TEST_ALWAYS_INLINE std::size_t operator()(__uint128_t data) const {
+    const std::size_t __a    = (std::size_t)(data & __mask);
+    const std::size_t __b    = (std::size_t)((data & (__mask << 64)) >> 64);
   }
 };
 
 struct UInt32Hash2 {
   UInt32Hash2() = default;
-  inline TEST_ALWAYS_INLINE
-  std::size_t operator()(uint32_t data) const {
-      const uint32_t __m = 0x5bd1e995;
-      const uint32_t __r = 24;
-      uint32_t __h = 4;
-      uint32_t __k = data;
-        __k *= __m;
-        __k ^= __k >> __r;
-        __k *= __m;
-        __h *= __m;
-        __h ^= __k;
-        __h ^= __h >> 13;
-        __h *= __m;
-        __h ^= __h >> 15;
+  inline TEST_ALWAYS_INLINE std::size_t operator()(uint32_t data) const {
+    uint32_t __h       = 4;
+    uint32_t __k       = data;
     return __h;
   }
 };
 
 struct UInt64Hash2 {
   UInt64Hash2() = default;
-  inline TEST_ALWAYS_INLINE
-  std::size_t operator()(uint64_t data) const {
-      return hash_len_0_to_8<8>(reinterpret_cast<const char*>(&data));
+  inline TEST_ALWAYS_INLINE std::size_t operator()(uint64_t data) const {
   }
 };
 
 // The sole purpose of this comparator is to be used in BM_Rehash, where
 // we need something slow enough to be easily noticable in benchmark results.
 // The default implementation of operator== for strings seems to be a little
 // too fast for that specific benchmark to reliably show a noticeable
 // improvement, but unoptimized bytewise comparison fits just right.
 // Early return is there just for convenience, since we only compare strings
 // of equal length in BM_Rehash.
 struct SlowStringEq {
   SlowStringEq() = default;
-  inline TEST_ALWAYS_INLINE
-  bool operator()(const std::string& lhs, const std::string& rhs) const {
-      if (lhs.size() != rhs.size()) return false;
+  inline TEST_ALWAYS_INLINE bool operator()(const std::string& lhs, const std::string& rhs) const {
+    if (lhs.size() != rhs.size())
+      return false;
 
-      bool eq = true;
-      for (size_t i = 0; i < lhs.size(); ++i) {
-          eq &= lhs[i] == rhs[i];
-      }
-      return eq;
   }
 };
 
 //----------------------------------------------------------------------------//
 //                               BM_Hash
 // ---------------------------------------------------------------------------//
 
 template <class HashFn, class GenInputs>
 void BM_Hash(benchmark::State& st, HashFn fn, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.data() + in.size();
-    std::size_t last_hash = 0;
-    benchmark::DoNotOptimize(&last_hash);
-    while (st.KeepRunning()) {
-        for (auto it = in.data(); it != end; ++it) {
-            benchmark::DoNotOptimize(last_hash += fn(*it));
-        }
-        benchmark::ClobberMemory();
-    }
+  auto in               = gen(st.range(0));
+  const auto end        = in.data() + in.size();
 }
 
-BENCHMARK_CAPTURE(BM_Hash,
-    uint32_random_std_hash,
-    std::hash<uint32_t>{},
-    getRandomIntegerInputs<uint32_t>) -> Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_Hash,
-    uint32_random_custom_hash,
-    UInt32Hash{},
-    getRandomIntegerInputs<uint32_t>) -> Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_Hash,
-    uint32_top_std_hash,
-    std::hash<uint32_t>{},
-    getSortedTopBitsIntegerInputs<uint32_t>) -> Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_Hash,
-    uint32_top_custom_hash,
-    UInt32Hash{},
-    getSortedTopBitsIntegerInputs<uint32_t>) -> Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_Hash, uint32_random_std_hash, std::hash<uint32_t>{}, getRandomIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(BM_Hash, uint32_random_custom_hash, UInt32Hash{}, getRandomIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(BM_Hash, uint32_top_std_hash, std::hash<uint32_t>{}, getSortedTopBitsIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
 
+BENCHMARK_CAPTURE(BM_Hash, uint32_top_custom_hash, UInt32Hash{}, getSortedTopBitsIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
 
 //----------------------------------------------------------------------------//
 //                       BM_InsertValue
 // ---------------------------------------------------------------------------//
 
-
 // Sorted Ascending //
-BENCHMARK_CAPTURE(BM_InsertValue,
-    unordered_set_uint32,
-    std::unordered_set<uint32_t>{},
-    getRandomIntegerInputs<uint32_t>)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_InsertValue,
-    unordered_set_uint32_sorted,
-    std::unordered_set<uint32_t>{},
-    getSortedIntegerInputs<uint32_t>)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(
+    BM_InsertValue, unordered_set_uint32, std::unordered_set<uint32_t>{}, getRandomIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(
+    BM_InsertValue, unordered_set_uint32_sorted, std::unordered_set<uint32_t>{}, getSortedIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
 
 // Top Bytes //
 BENCHMARK_CAPTURE(BM_InsertValue,
                   unordered_set_top_bits_uint32,
                   std::unordered_set<uint32_t>{},
-    getSortedTopBitsIntegerInputs<uint32_t>)->Arg(TestNumInputs);
+                  getSortedTopBitsIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_CAPTURE(BM_InsertValueRehash,
                   unordered_set_top_bits_uint32,
                   std::unordered_set<uint32_t, UInt32Hash>{},
-    getSortedTopBitsIntegerInputs<uint32_t>)->Arg(TestNumInputs);
+                  getSortedTopBitsIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
 
 // String //
-BENCHMARK_CAPTURE(BM_InsertValue,
-    unordered_set_string,
-    std::unordered_set<std::string>{},
-    getRandomStringInputs)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_InsertValue, unordered_set_string, std::unordered_set<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
 
-BENCHMARK_CAPTURE(BM_InsertValueRehash,
-    unordered_set_string,
-    std::unordered_set<std::string>{},
-    getRandomStringInputs)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_InsertValueRehash, unordered_set_string, std::unordered_set<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
 
 //----------------------------------------------------------------------------//
 //                         BM_Find
 // ---------------------------------------------------------------------------//
 
 // Random //
-BENCHMARK_CAPTURE(BM_Find,
-    unordered_set_random_uint64,
-    std::unordered_set<uint64_t>{},
-    getRandomIntegerInputs<uint64_t>)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(
+    BM_Find, unordered_set_random_uint64, std::unordered_set<uint64_t>{}, getRandomIntegerInputs<uint64_t>)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_CAPTURE(BM_FindRehash,
                   unordered_set_random_uint64,
                   std::unordered_set<uint64_t, UInt64Hash>{},
-    getRandomIntegerInputs<uint64_t>)->Arg(TestNumInputs);
+                  getRandomIntegerInputs<uint64_t>)
+    ->Arg(TestNumInputs);
 
 // Sorted //
-BENCHMARK_CAPTURE(BM_Find,
-    unordered_set_sorted_uint64,
-    std::unordered_set<uint64_t>{},
-    getSortedIntegerInputs<uint64_t>)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(
+    BM_Find, unordered_set_sorted_uint64, std::unordered_set<uint64_t>{}, getSortedIntegerInputs<uint64_t>)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_CAPTURE(BM_FindRehash,
                   unordered_set_sorted_uint64,
                   std::unordered_set<uint64_t, UInt64Hash>{},
-    getSortedIntegerInputs<uint64_t>)->Arg(TestNumInputs);
-
+                  getSortedIntegerInputs<uint64_t>)
+    ->Arg(TestNumInputs);
 
 // Sorted //
 #if 1
 BENCHMARK_CAPTURE(BM_Find,
                   unordered_set_sorted_uint128,
                   std::unordered_set<__uint128_t, UInt128Hash>{},
-    getSortedTopBitsIntegerInputs<__uint128_t>)->Arg(TestNumInputs);
+                  getSortedTopBitsIntegerInputs<__uint128_t>)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_CAPTURE(BM_FindRehash,
                   unordered_set_sorted_uint128,
                   std::unordered_set<__uint128_t, UInt128Hash>{},
-    getSortedTopBitsIntegerInputs<__uint128_t>)->Arg(TestNumInputs);
+                  getSortedTopBitsIntegerInputs<__uint128_t>)
+    ->Arg(TestNumInputs);
 #endif
 
 // Sorted //
-BENCHMARK_CAPTURE(BM_Find,
-    unordered_set_sorted_uint32,
-    std::unordered_set<uint32_t>{},
-    getSortedIntegerInputs<uint32_t>)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(
+    BM_Find, unordered_set_sorted_uint32, std::unordered_set<uint32_t>{}, getSortedIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_CAPTURE(BM_FindRehash,
                   unordered_set_sorted_uint32,
                   std::unordered_set<uint32_t, UInt32Hash2>{},
-    getSortedIntegerInputs<uint32_t>)->Arg(TestNumInputs);
+                  getSortedIntegerInputs<uint32_t>)
+    ->Arg(TestNumInputs);
 
 // Sorted Ascending //
-BENCHMARK_CAPTURE(BM_Find,
-    unordered_set_sorted_large_uint64,
-    std::unordered_set<uint64_t>{},
-    getSortedLargeIntegerInputs<uint64_t>)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(
+    BM_Find, unordered_set_sorted_large_uint64, std::unordered_set<uint64_t>{}, getSortedLargeIntegerInputs<uint64_t>)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_CAPTURE(BM_FindRehash,
                   unordered_set_sorted_large_uint64,
                   std::unordered_set<uint64_t, UInt64Hash>{},
-    getSortedLargeIntegerInputs<uint64_t>)->Arg(TestNumInputs);
-
+                  getSortedLargeIntegerInputs<uint64_t>)
+    ->Arg(TestNumInputs);
 
 // Top Bits //
-BENCHMARK_CAPTURE(BM_Find,
-    unordered_set_top_bits_uint64,
-    std::unordered_set<uint64_t>{},
-    getSortedTopBitsIntegerInputs<uint64_t>)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(
+    BM_Find, unordered_set_top_bits_uint64, std::unordered_set<uint64_t>{}, getSortedTopBitsIntegerInputs<uint64_t>)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_CAPTURE(BM_FindRehash,
                   unordered_set_top_bits_uint64,
                   std::unordered_set<uint64_t, UInt64Hash>{},
-    getSortedTopBitsIntegerInputs<uint64_t>)->Arg(TestNumInputs);
+                  getSortedTopBitsIntegerInputs<uint64_t>)
+    ->Arg(TestNumInputs);
 
 // String //
-BENCHMARK_CAPTURE(BM_Find,
-    unordered_set_string,
-    std::unordered_set<std::string>{},
-    getRandomStringInputs)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_Find, unordered_set_string, std::unordered_set<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
 
-BENCHMARK_CAPTURE(BM_FindRehash,
-    unordered_set_string,
-    std::unordered_set<std::string>{},
-    getRandomStringInputs)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_FindRehash, unordered_set_string, std::unordered_set<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
 
 //----------------------------------------------------------------------------//
 //                         BM_Rehash
 // ---------------------------------------------------------------------------//
 
 BENCHMARK_CAPTURE(BM_Rehash,
                   unordered_set_string_arg,
                   std::unordered_set<std::string, std::hash<std::string>, SlowStringEq>{},
-    getRandomStringInputs)->Arg(TestNumInputs);
+                  getRandomStringInputs)
+    ->Arg(TestNumInputs);
 
-BENCHMARK_CAPTURE(BM_Rehash,
-    unordered_set_int_arg,
-    std::unordered_set<int>{},
-    getRandomIntegerInputs<int>)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_Rehash, unordered_set_int_arg, std::unordered_set<int>{}, getRandomIntegerInputs<int>)
+    ->Arg(TestNumInputs);
 
 ///////////////////////////////////////////////////////////////////////////////
-BENCHMARK_CAPTURE(BM_InsertDuplicate,
-    unordered_set_int,
-    std::unordered_set<int>{},
-    getRandomIntegerInputs<int>)->Arg(TestNumInputs);
-BENCHMARK_CAPTURE(BM_InsertDuplicate,
-    unordered_set_string,
-    std::unordered_set<std::string>{},
-    getRandomStringInputs)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_EmplaceDuplicate,
-    unordered_set_int,
-    std::unordered_set<int>{},
-    getRandomIntegerInputs<int>)->Arg(TestNumInputs);
-BENCHMARK_CAPTURE(BM_EmplaceDuplicate,
-    unordered_set_string,
-    std::unordered_set<std::string>{},
-    getRandomStringInputs)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_InsertDuplicate,
-    unordered_set_int_insert_arg,
-    std::unordered_set<int>{},
-    getRandomIntegerInputs<int>)->Arg(TestNumInputs);
-BENCHMARK_CAPTURE(BM_InsertDuplicate,
-    unordered_set_string_insert_arg,
-    std::unordered_set<std::string>{},
-    getRandomStringInputs)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_EmplaceDuplicate,
-    unordered_set_int_insert_arg,
-    std::unordered_set<int>{},
-    getRandomIntegerInputs<unsigned>)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_EmplaceDuplicate,
-    unordered_set_string_arg,
-    std::unordered_set<std::string>{},
-    getRandomCStringInputs)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_InsertDuplicate, unordered_set_int, std::unordered_set<int>{}, getRandomIntegerInputs<int>)
+    ->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_InsertDuplicate, unordered_set_string, std::unordered_set<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(BM_EmplaceDuplicate, unordered_set_int, std::unordered_set<int>{}, getRandomIntegerInputs<int>)
+    ->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_EmplaceDuplicate, unordered_set_string, std::unordered_set<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(
+    BM_InsertDuplicate, unordered_set_int_insert_arg, std::unordered_set<int>{}, getRandomIntegerInputs<int>)
+    ->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(
+    BM_InsertDuplicate, unordered_set_string_insert_arg, std::unordered_set<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(
+    BM_EmplaceDuplicate, unordered_set_int_insert_arg, std::unordered_set<int>{}, getRandomIntegerInputs<unsigned>)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(
+    BM_EmplaceDuplicate, unordered_set_string_arg, std::unordered_set<std::string>{}, getRandomCStringInputs)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_MAIN();

libcxx/benchmarks/vector_operations.bench.cpp

-#include <vector>
-#include <functional>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
+#include <functional>
+#include <vector>
 
 #include "benchmark/benchmark.h"
 
 #include "ContainerBenchmarks.h"
 #include "GenerateInput.h"
 
 using namespace ContainerBenchmarks;
 
 constexpr std::size_t TestNumInputs = 1024;
 
-BENCHMARK_CAPTURE(BM_ConstructSize,
-    vector_byte,
-    std::vector<unsigned char>{})->Arg(5140480);
-
-BENCHMARK_CAPTURE(BM_CopyConstruct,
-    vector_int,
-    std::vector<int>{})->Arg(5140480);
-
-BENCHMARK_CAPTURE(BM_Assignment,
-    vector_int,
-    std::vector<int>{})->Arg(5140480);
-
-BENCHMARK_CAPTURE(BM_ConstructSizeValue,
-    vector_byte,
-    std::vector<unsigned char>{}, 0)->Arg(5140480);
-
-BENCHMARK_CAPTURE(BM_ConstructIterIter,
-  vector_char,
-  std::vector<char>{},
-  getRandomIntegerInputs<char>)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_ConstructIterIter,
-  vector_size_t,
-  std::vector<size_t>{},
-  getRandomIntegerInputs<size_t>)->Arg(TestNumInputs);
-
-BENCHMARK_CAPTURE(BM_ConstructIterIter,
-  vector_string,
-  std::vector<std::string>{},
-  getRandomStringInputs)->Arg(TestNumInputs);
+BENCHMARK_CAPTURE(BM_ConstructSize, vector_byte, std::vector<unsigned char>{})->Arg(5140480);
+
+BENCHMARK_CAPTURE(BM_CopyConstruct, vector_int, std::vector<int>{})->Arg(5140480);
+
+BENCHMARK_CAPTURE(BM_Assignment, vector_int, std::vector<int>{})->Arg(5140480);
+
+BENCHMARK_CAPTURE(BM_ConstructSizeValue, vector_byte, std::vector<unsigned char>{}, 0)->Arg(5140480);
+
+BENCHMARK_CAPTURE(BM_ConstructIterIter, vector_char, std::vector<char>{}, getRandomIntegerInputs<char>)
+    ->Arg(TestNumInputs);
+
+BENCHMARK_CAPTURE(BM_ConstructIterIter, vector_size_t, std::vector<size_t>{}, getRandomIntegerInputs<size_t>)
+    ->Arg(TestNumInputs);
 
+BENCHMARK_CAPTURE(BM_ConstructIterIter, vector_string, std::vector<std::string>{}, getRandomStringInputs)
+    ->Arg(TestNumInputs);
 
 BENCHMARK_MAIN();

libcxx/utils/data/ignore_format.txt

-libcxx/benchmarks/CartesianBenchmarks.h
-libcxx/benchmarks/ContainerBenchmarks.h
-libcxx/benchmarks/GenerateInput.h
-libcxx/benchmarks/Utilities.h
-libcxx/benchmarks/VariantBenchmarks.h
-libcxx/benchmarks/algorithms/common.h
-libcxx/benchmarks/algorithms/lower_bound.bench.cpp
-libcxx/benchmarks/algorithms/make_heap.bench.cpp
-libcxx/benchmarks/algorithms/make_heap_then_sort_heap.bench.cpp
-libcxx/benchmarks/algorithms.partition_point.bench.cpp
-libcxx/benchmarks/algorithms/pop_heap.bench.cpp
-libcxx/benchmarks/algorithms/push_heap.bench.cpp
-libcxx/benchmarks/algorithms/ranges_make_heap.bench.cpp
-libcxx/benchmarks/algorithms/ranges_make_heap_then_sort_heap.bench.cpp
-libcxx/benchmarks/algorithms/ranges_pop_heap.bench.cpp
-libcxx/benchmarks/algorithms/ranges_push_heap.bench.cpp
-libcxx/benchmarks/algorithms/ranges_sort.bench.cpp
-libcxx/benchmarks/algorithms/ranges_sort_heap.bench.cpp
-libcxx/benchmarks/algorithms/ranges_stable_sort.bench.cpp
-libcxx/benchmarks/algorithms/sort.bench.cpp
-libcxx/benchmarks/algorithms/sort_heap.bench.cpp
-libcxx/benchmarks/algorithms/stable_sort.bench.cpp
-libcxx/benchmarks/allocation.bench.cpp
-libcxx/benchmarks/deque.bench.cpp
-libcxx/benchmarks/filesystem.bench.cpp
-libcxx/benchmarks/formatter_float.bench.cpp
-libcxx/benchmarks/formatter_int.bench.cpp
-libcxx/benchmarks/format_to.bench.cpp
-libcxx/benchmarks/format_to_n.bench.cpp
-libcxx/benchmarks/function.bench.cpp
-libcxx/benchmarks/map.bench.cpp
-libcxx/benchmarks/ordered_set.bench.cpp
-libcxx/benchmarks/random.bench.cpp
-libcxx/benchmarks/string.bench.cpp
-libcxx/benchmarks/stringstream.bench.cpp
-libcxx/benchmarks/unordered_set_operations.bench.cpp
-libcxx/benchmarks/vector_operations.bench.cpp
 libcxx/include/__algorithm/binary_search.h
 libcxx/include/__algorithm/clamp.h
 libcxx/include/__algorithm/comp_ref_type.h
 libcxx/include/__algorithm/copy_backward.h
 libcxx/include/__algorithm/copy_if.h
 libcxx/include/__algorithm/copy_move_common.h
 libcxx/include/__algorithm/copy_n.h
 libcxx/include/__algorithm/equal.h