From 2e4d666eec1a372d4b64c527d6c4945ad98d2b58 Mon Sep 17 00:00:00 2001
From: David Robillard <d@drobilla.net>
Date: Fri, 16 Sep 2022 21:19:57 -0400
Subject: Update clang-format configuration

---
 benchmark/bench_bitvec.cpp | 461 +++++++++++++++++++++------------------------
 1 file changed, 220 insertions(+), 241 deletions(-)

(limited to 'benchmark/bench_bitvec.cpp')

diff --git a/benchmark/bench_bitvec.cpp b/benchmark/bench_bitvec.cpp
index 6580af9..5c885b1 100644
--- a/benchmark/bench_bitvec.cpp
+++ b/benchmark/bench_bitvec.cpp
@@ -29,324 +29,303 @@
 #include <string>
 #include <vector>
 
-template <class T, size_t N>
-struct BenchAnd
-{
-	Duration operator()(Context& ctx)
-	{
-		const T v = make_random_bitvec<T, N>(ctx);
-		T       r = make_random_bitvec<T, N>(ctx);
-
-		return run_bench([&](auto) { r &= v; });
-	}
+template<class T, size_t N>
+struct BenchAnd {
+  Duration operator()(Context& ctx)
+  {
+    const T v = make_random_bitvec<T, N>(ctx);
+    T       r = make_random_bitvec<T, N>(ctx);
+
+    return run_bench([&](auto) { r &= v; });
+  }
 };
 
-template <class T, size_t N>
-struct BenchOr
-{
-	Duration operator()(Context& ctx)
-	{
-		const T v = make_random_bitvec<T, N>(ctx);
-		T       r = make_random_bitvec<T, N>(ctx);
+template<class T, size_t N>
+struct BenchOr {
+  Duration operator()(Context& ctx)
+  {
+    const T v = make_random_bitvec<T, N>(ctx);
+    T       r = make_random_bitvec<T, N>(ctx);
 
-		return run_bench([&](auto) { r |= v; });
-	}
+    return run_bench([&](auto) { r |= v; });
+  }
 };
 
-template <class T, size_t N>
-struct BenchXor
-{
-	Duration operator()(Context& ctx)
-	{
-		const T v = make_random_bitvec<T, N>(ctx);
-		T       r = make_random_bitvec<T, N>(ctx);
+template<class T, size_t N>
+struct BenchXor {
+  Duration operator()(Context& ctx)
+  {
+    const T v = make_random_bitvec<T, N>(ctx);
+    T       r = make_random_bitvec<T, N>(ctx);
 
-		return run_bench([&](auto) { r ^= v; });
-	}
+    return run_bench([&](auto) { r ^= v; });
+  }
 };
 
-template <class T, size_t N>
-struct BenchSetOne
-{
-	Duration operator()(Context& ctx)
-	{
-		T v = make_random_bitvec<T, N>(ctx);
-		return run_bench([&](const auto i) { v.set(i % N); });
-	}
+template<class T, size_t N>
+struct BenchSetOne {
+  Duration operator()(Context& ctx)
+  {
+    T v = make_random_bitvec<T, N>(ctx);
+    return run_bench([&](const auto i) { v.set(i % N); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchSetAll
-{
-	Duration operator()(Context& ctx)
-	{
-		T v = make_random_bitvec<T, N>(ctx);
-		return run_bench([&](auto) { v.set(); });
-	}
+template<class T, size_t N>
+struct BenchSetAll {
+  Duration operator()(Context& ctx)
+  {
+    T v = make_random_bitvec<T, N>(ctx);
+    return run_bench([&](auto) { v.set(); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchResetOne
-{
-	Duration operator()(Context& ctx)
-	{
-		T v = make_random_bitvec<T, N>(ctx);
-		return run_bench([&](const auto i) { v.reset(i % N); });
-	}
+template<class T, size_t N>
+struct BenchResetOne {
+  Duration operator()(Context& ctx)
+  {
+    T v = make_random_bitvec<T, N>(ctx);
+    return run_bench([&](const auto i) { v.reset(i % N); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchResetAll
-{
-	Duration operator()(Context& ctx)
-	{
-		T v = make_random_bitvec<T, N>(ctx);
-		return run_bench([&](auto) { v.reset(); });
-	}
+template<class T, size_t N>
+struct BenchResetAll {
+  Duration operator()(Context& ctx)
+  {
+    T v = make_random_bitvec<T, N>(ctx);
+    return run_bench([&](auto) { v.reset(); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchFlipOne
-{
-	Duration operator()(Context& ctx)
-	{
-		T v = make_random_bitvec<T, N>(ctx);
-		return run_bench([&](const auto i) { v.flip(i % N); });
-	}
+template<class T, size_t N>
+struct BenchFlipOne {
+  Duration operator()(Context& ctx)
+  {
+    T v = make_random_bitvec<T, N>(ctx);
+    return run_bench([&](const auto i) { v.flip(i % N); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchFlipAll
-{
-	Duration operator()(Context& ctx)
-	{
-		T v = make_random_bitvec<T, N>(ctx);
-		return run_bench([&](auto) { v.flip(); });
-	}
+template<class T, size_t N>
+struct BenchFlipAll {
+  Duration operator()(Context& ctx)
+  {
+    T v = make_random_bitvec<T, N>(ctx);
+    return run_bench([&](auto) { v.flip(); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchNone
-{
-	Duration operator()(Context& ctx)
-	{
-		T    v = make_random_bitvec<T, N>(ctx);
-		bool r = false;
-		(void)r;
-
-		return run_bench([&](auto) { r = v.none(); });
-	}
+template<class T, size_t N>
+struct BenchNone {
+  Duration operator()(Context& ctx)
+  {
+    T    v = make_random_bitvec<T, N>(ctx);
+    bool r = false;
+    (void)r;
+
+    return run_bench([&](auto) { r = v.none(); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchCount
-{
-	Duration operator()(Context& ctx)
-	{
-		T               v = make_random_bitvec<T, N>(ctx);
-		volatile size_t r = 0;
-		(void)r;
-
-		return run_bench([&](auto) { r = v.count(); });
-	}
+template<class T, size_t N>
+struct BenchCount {
+  Duration operator()(Context& ctx)
+  {
+    T               v = make_random_bitvec<T, N>(ctx);
+    volatile size_t r = 0;
+    (void)r;
+
+    return run_bench([&](auto) { r = v.count(); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchLeftShift
-{
-	Duration operator()(Context& ctx)
-	{
-		const T v = make_random_bitvec<T, N>(ctx);
-		T       r = v;
-		return run_bench([&](const auto i) { r <<= (i % N); });
-	}
+template<class T, size_t N>
+struct BenchLeftShift {
+  Duration operator()(Context& ctx)
+  {
+    const T v = make_random_bitvec<T, N>(ctx);
+    T       r = v;
+    return run_bench([&](const auto i) { r <<= (i % N); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchRightShift
-{
-	Duration operator()(Context& ctx)
-	{
-		const T v = make_random_bitvec<T, N>(ctx);
-		T       r = v;
-		return run_bench([&](const auto i) { r >>= (i % N); });
-	}
+template<class T, size_t N>
+struct BenchRightShift {
+  Duration operator()(Context& ctx)
+  {
+    const T v = make_random_bitvec<T, N>(ctx);
+    T       r = v;
+    return run_bench([&](const auto i) { r >>= (i % N); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchLeftRotate
-{
-	Duration operator()(Context& ctx)
-	{
-		T v = make_random_bitvec<T, N>(ctx);
-		return run_bench([&](const auto i) { v.rotl(i % N); });
-	}
+template<class T, size_t N>
+struct BenchLeftRotate {
+  Duration operator()(Context& ctx)
+  {
+    T v = make_random_bitvec<T, N>(ctx);
+    return run_bench([&](const auto i) { v.rotl(i % N); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchRightRotate
-{
-	Duration operator()(Context& ctx)
-	{
-		T             v = make_random_bitvec<T, N>(ctx);
-		volatile bool r = false;
-		(void)r;
-
-		return run_bench([&](const auto i) {
-			v.rotr(i % N);
-			r = v.test(0);
-		});
-	}
+template<class T, size_t N>
+struct BenchRightRotate {
+  Duration operator()(Context& ctx)
+  {
+    T             v = make_random_bitvec<T, N>(ctx);
+    volatile bool r = false;
+    (void)r;
+
+    return run_bench([&](const auto i) {
+      v.rotr(i % N);
+      r = v.test(0);
+    });
+  }
 };
 
-template <class T, size_t N>
-struct BenchFindFirst
-{
-	Duration operator()(Context& ctx)
-	{
-		T               v = make_random_bitvec<T, N>(ctx);
-		volatile size_t r = 0;
-		(void)r;
-
-		return run_bench([&](auto) { r = v.find_first(); });
-	}
+template<class T, size_t N>
+struct BenchFindFirst {
+  Duration operator()(Context& ctx)
+  {
+    T               v = make_random_bitvec<T, N>(ctx);
+    volatile size_t r = 0;
+    (void)r;
+
+    return run_bench([&](auto) { r = v.find_first(); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchGrayCode
-{
-	Duration operator()(Context& ctx)
-	{
-		const T v = make_random_bitvec<T, N>(ctx);
-		T       r = v;
+template<class T, size_t N>
+struct BenchGrayCode {
+  Duration operator()(Context& ctx)
+  {
+    const T v = make_random_bitvec<T, N>(ctx);
+    T       r = v;
 
-		return run_bench([&](auto) { chilbert::detail::gray_code(r); });
-	}
+    return run_bench([&](auto) { chilbert::detail::gray_code(r); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchGrayCodeInv
-{
-	Duration operator()(Context& ctx)
-	{
-		const T v = make_random_bitvec<T, N>(ctx);
-		T       r = v;
+template<class T, size_t N>
+struct BenchGrayCodeInv {
+  Duration operator()(Context& ctx)
+  {
+    const T v = make_random_bitvec<T, N>(ctx);
+    T       r = v;
 
-		return run_bench([&](auto) { chilbert::detail::gray_code_inv(r); });
-	}
+    return run_bench([&](auto) { chilbert::detail::gray_code_inv(r); });
+  }
 };
 
-template <class T, size_t N>
-struct BenchComparison
-{
-	Duration operator()(Context& ctx)
-	{
-		std::vector<T> vecs;
-		for (size_t i = 0; i < 32; ++i) {
-			vecs.emplace_back(make_random_bitvec<T, N>(ctx));
-		}
-
-		volatile bool r = false;
-
-		return run_bench([&](const auto i) {
-			r |= vecs[i % vecs.size()] < vecs[(i + 1) % vecs.size()];
-		});
-	}
+template<class T, size_t N>
+struct BenchComparison {
+  Duration operator()(Context& ctx)
+  {
+    std::vector<T> vecs;
+    for (size_t i = 0; i < 32; ++i) {
+      vecs.emplace_back(make_random_bitvec<T, N>(ctx));
+    }
+
+    volatile bool r = false;
+
+    return run_bench([&](const auto i) {
+      r |= vecs[i % vecs.size()] < vecs[(i + 1) % vecs.size()];
+    });
+  }
 };
 
-template <class T, size_t N>
-struct BenchIteration
-{
-	Duration operator()(Context& ctx)
-	{
-		T             v = make_random_bitvec<T, N>(ctx);
-		auto          i = v.begin();
-		volatile bool r = false;
-		return run_bench([&](const auto) {
-			r = (++i == v.end());
-			if (r) {
-				i = v.begin();
-			}
-		});
-	}
+template<class T, size_t N>
+struct BenchIteration {
+  Duration operator()(Context& ctx)
+  {
+    T             v = make_random_bitvec<T, N>(ctx);
+    auto          i = v.begin();
+    volatile bool r = false;
+    return run_bench([&](const auto) {
+      r = (++i == v.end());
+      if (r) {
+        i = v.begin();
+      }
+    });
+  }
 };
 
 /// Run benchmark for size N
-template <template <class U, size_t M> class Bench, size_t N>
+template<template<class U, size_t M> class Bench, size_t N>
 void
 bench_row(Context& ctx, std::ostream& os)
 {
-	std::array<Duration, 4> results = {
-	  ((N <= chilbert::SmallBitVec::bits_per_rack)
-	     ? Bench<chilbert::SmallBitVec, N>{}(ctx)
-	     : Duration{}),
-	  Bench<chilbert::StaticBitVec<N>, N>{}(ctx),
-	  Bench<chilbert::BoundedBitVec<N>, N>{}(ctx),
-	  Bench<chilbert::DynamicBitVec, N>{}(ctx),
-	};
-
-	write_row(os, N, results);
+  std::array<Duration, 4> results = {
+    ((N <= chilbert::SmallBitVec::bits_per_rack)
+       ? Bench<chilbert::SmallBitVec, N>{}(ctx)
+       : Duration{}),
+    Bench<chilbert::StaticBitVec<N>, N>{}(ctx),
+    Bench<chilbert::BoundedBitVec<N>, N>{}(ctx),
+    Bench<chilbert::DynamicBitVec, N>{}(ctx),
+  };
+
+  write_row(os, N, results);
 }
 
 /// Terminate recursion
-template <template <class U, size_t M> class Bench>
+template<template<class U, size_t M> class Bench>
 void
 bench_rec(Context&, std::ostream&)
-{
-}
+{}
 
 /// Run benchmark for sizes N, Ns... (recursive helper)
-template <template <class U, size_t M> class Bench, size_t N, size_t... Ns>
+template<template<class U, size_t M> class Bench, size_t N, size_t... Ns>
 void
 bench_rec(Context& ctx, std::ostream& os)
 {
-	bench_row<Bench, N>(ctx, os);
-	bench_rec<Bench, Ns...>(ctx, os);
+  bench_row<Bench, N>(ctx, os);
+  bench_rec<Bench, Ns...>(ctx, os);
 }
 
 /// Run benchmark
-template <template <class U, size_t M> class Bench>
+template<template<class U, size_t M> class Bench>
 void
 bench(Context& ctx, const std::string& name)
 {
-	std::ofstream out("bitvec_" + name + ".txt");
-	out << "n\tsmall\tstatic\tbounded\tdynamic\n";
-	bench_rec<Bench, 16, 32, 64, 128, 256, 512>(ctx, out);
+  std::ofstream out("bitvec_" + name + ".txt");
+  out << "n\tsmall\tstatic\tbounded\tdynamic\n";
+  bench_rec<Bench, 16, 32, 64, 128, 256, 512>(ctx, out);
 }
 
 int
 main()
 {
-	Context ctx;
+  Context ctx;
 
-	bench<BenchAnd>(ctx, "and");
-	bench<BenchOr>(ctx, "or");
-	bench<BenchXor>(ctx, "xor");
-	bench<BenchNone>(ctx, "none");
+  bench<BenchAnd>(ctx, "and");
+  bench<BenchOr>(ctx, "or");
+  bench<BenchXor>(ctx, "xor");
+  bench<BenchNone>(ctx, "none");
 
-	bench<BenchSetOne>(ctx, "set_one");
-	bench<BenchSetAll>(ctx, "set_all");
+  bench<BenchSetOne>(ctx, "set_one");
+  bench<BenchSetAll>(ctx, "set_all");
 
-	bench<BenchResetOne>(ctx, "reset_one");
-	bench<BenchResetAll>(ctx, "reset_all");
+  bench<BenchResetOne>(ctx, "reset_one");
+  bench<BenchResetAll>(ctx, "reset_all");
 
-	bench<BenchFlipOne>(ctx, "flip_one");
-	bench<BenchFlipAll>(ctx, "flip_all");
+  bench<BenchFlipOne>(ctx, "flip_one");
+  bench<BenchFlipAll>(ctx, "flip_all");
 
-	bench<BenchCount>(ctx, "count");
-	bench<BenchFindFirst>(ctx, "find_first");
+  bench<BenchCount>(ctx, "count");
+  bench<BenchFindFirst>(ctx, "find_first");
 
-	bench<BenchLeftShift>(ctx, "left_shift");
-	bench<BenchRightShift>(ctx, "right_shift");
+  bench<BenchLeftShift>(ctx, "left_shift");
+  bench<BenchRightShift>(ctx, "right_shift");
 
-	bench<BenchLeftRotate>(ctx, "left_rotate");
-	bench<BenchRightRotate>(ctx, "right_rotate");
+  bench<BenchLeftRotate>(ctx, "left_rotate");
+  bench<BenchRightRotate>(ctx, "right_rotate");
 
-	bench<BenchGrayCode>(ctx, "gray_code");
-	bench<BenchGrayCodeInv>(ctx, "gray_code_inv");
+  bench<BenchGrayCode>(ctx, "gray_code");
+  bench<BenchGrayCodeInv>(ctx, "gray_code_inv");
 
-	bench<BenchComparison>(ctx, "comparison");
-	bench<BenchIteration>(ctx, "iteration");
+  bench<BenchComparison>(ctx, "comparison");
+  bench<BenchIteration>(ctx, "iteration");
 
-	return 0;
+  return 0;
 }
-- 
cgit v1.2.1