Skip to content

Commit 1c60ad7

Browse files
alex-sparusalex-sparus
committed
Ran pre-commit run --all-files 
1 parent e00461b commit 1c60ad7

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

63 files changed

+775
-777
lines changed

‎benchmark/extra/refcounting.cpp

+30-41
Original file line numberDiff line numberDiff line change
@@ -8,15 +8,15 @@
88

99
#include <immer/detail/ref_count_base.hpp>
1010

11-
#include <nonius.h++>
1211
#include <boost/intrusive_ptr.hpp>
12+
#include <nonius.h++>
1313

14+
#include <array>
1415
#include <atomic>
1516
#include <cstdlib>
1617
#include <iterator>
1718
#include <memory>
1819
#include <utility>
19-
#include <array>
2020
#include <vector>
2121

2222
NONIUS_PARAM(N, std::size_t{1000})
@@ -29,64 +29,55 @@ struct object_t : immer::detail::ref_count_base<object_t>
2929
auto make_data()
3030
{
3131
auto objs = std::array<std::unique_ptr<object_t>, benchmark_size>();
32-
std::generate(objs.begin(), objs.end(), [] {
33-
return std::make_unique<object_t>();
34-
});
32+
std::generate(
33+
objs.begin(), objs.end(), [] { return std::make_unique<object_t>(); });
3534
auto refs = std::array<object_t*, benchmark_size>();
3635
std::transform(objs.begin(), objs.end(), refs.begin(), [](auto& obj) {
3736
return obj.get();
3837
});
39-
return make_pair(std::move(objs),
40-
std::move(refs));
38+
return make_pair(std::move(objs), std::move(refs));
4139
}
4240

43-
NONIUS_BENCHMARK("intrusive_ptr", [] (nonius::chronometer meter)
44-
{
41+
NONIUS_BENCHMARK("intrusive_ptr", [](nonius::chronometer meter) {
4542
auto arr = std::array<boost::intrusive_ptr<object_t>, benchmark_size>{};
46-
auto storage = std::vector<
47-
nonius::storage_for<
48-
std::array<boost::intrusive_ptr<object_t>, benchmark_size>>> (
49-
meter.runs());
50-
std::generate(arr.begin(), arr.end(), [] {
51-
return new object_t{};
52-
});
53-
meter.measure([&] (int i) {
54-
storage[i].construct(arr);
55-
});
43+
auto storage = std::vector<nonius::storage_for<
44+
std::array<boost::intrusive_ptr<object_t>, benchmark_size>>>(
45+
meter.runs());
46+
std::generate(arr.begin(), arr.end(), [] { return new object_t{}; });
47+
meter.measure([&](int i) { storage[i].construct(arr); });
5648
})
5749

58-
NONIUS_BENCHMARK("generic", [] (nonius::chronometer meter)
59-
{
60-
auto data = make_data();
50+
NONIUS_BENCHMARK("generic", [](nonius::chronometer meter) {
51+
auto data = make_data();
6152
auto& refs = data.second;
6253
object_t* r[benchmark_size];
6354

6455
meter.measure([&] {
65-
std::transform(refs.begin(), refs.end(), r, [] (auto& p) {
66-
if (p) p->ref_count.fetch_add(1, std::memory_order_relaxed);
56+
std::transform(refs.begin(), refs.end(), r, [](auto& p) {
57+
if (p)
58+
p->ref_count.fetch_add(1, std::memory_order_relaxed);
6759
return p;
6860
});
6961
return r;
7062
});
7163
})
7264

73-
NONIUS_BENCHMARK("manual", [] (nonius::chronometer meter)
74-
{
75-
auto data = make_data();
65+
NONIUS_BENCHMARK("manual", [](nonius::chronometer meter) {
66+
auto data = make_data();
7667
auto& refs = data.second;
7768
object_t* r[benchmark_size];
7869

7970
meter.measure([&] {
8071
for (auto& p : refs)
81-
if (p) p->ref_count.fetch_add(1, std::memory_order_relaxed);
72+
if (p)
73+
p->ref_count.fetch_add(1, std::memory_order_relaxed);
8274
std::copy(refs.begin(), refs.end(), r);
8375
return r;
8476
});
8577
})
8678

87-
NONIUS_BENCHMARK("manual - unroll", [] (nonius::chronometer meter)
88-
{
89-
auto data = make_data();
79+
NONIUS_BENCHMARK("manual - unroll", [](nonius::chronometer meter) {
80+
auto data = make_data();
9081
auto& refs = data.second;
9182
object_t* r[benchmark_size];
9283

@@ -103,9 +94,8 @@ NONIUS_BENCHMARK("manual - unroll", [] (nonius::chronometer meter)
10394
});
10495
})
10596

106-
NONIUS_BENCHMARK("manual - nocheck", [] (nonius::chronometer meter)
107-
{
108-
auto data = make_data();
97+
NONIUS_BENCHMARK("manual - nocheck", [](nonius::chronometer meter) {
98+
auto data = make_data();
10999
auto& refs = data.second;
110100
object_t* r[benchmark_size];
111101

@@ -117,9 +107,8 @@ NONIUS_BENCHMARK("manual - nocheck", [] (nonius::chronometer meter)
117107
});
118108
})
119109

120-
NONIUS_BENCHMARK("manual - constant", [] (nonius::chronometer meter)
121-
{
122-
auto data = make_data();
110+
NONIUS_BENCHMARK("manual - constant", [](nonius::chronometer meter) {
111+
auto data = make_data();
123112
auto& refs = data.second;
124113
object_t* r[benchmark_size];
125114

@@ -131,15 +120,15 @@ NONIUS_BENCHMARK("manual - constant", [] (nonius::chronometer meter)
131120
});
132121
})
133122

134-
NONIUS_BENCHMARK("manual - memcopy", [] (nonius::chronometer meter)
135-
{
136-
auto data = make_data();
123+
NONIUS_BENCHMARK("manual - memcopy", [](nonius::chronometer meter) {
124+
auto data = make_data();
137125
auto& refs = data.second;
138126
object_t* r[benchmark_size];
139127

140128
meter.measure([&] {
141129
for (auto& p : refs)
142-
if (p) p->ref_count.fetch_add(1, std::memory_order_relaxed);
130+
if (p)
131+
p->ref_count.fetch_add(1, std::memory_order_relaxed);
143132
std::memcpy(r, &refs[0], sizeof(object_t*) * benchmark_size);
144133
return r;
145134
});

‎benchmark/set/access.hpp

+23-31
Original file line numberDiff line numberDiff line change
@@ -10,30 +10,29 @@
1010

1111
#include "benchmark/config.hpp"
1212

13-
#include <immer/set.hpp>
14-
#include <hash_trie.hpp> // Phil Nash
1513
#include <boost/container/flat_set.hpp>
14+
#include <hash_trie.hpp> // Phil Nash
15+
#include <immer/set.hpp>
1616
#include <set>
1717
#include <unordered_set>
1818

1919
namespace {
2020

21-
template <typename T=unsigned>
21+
template <typename T = unsigned>
2222
auto make_generator_ranged(std::size_t runs)
2323
{
2424
assert(runs > 0);
2525
auto engine = std::default_random_engine{13};
26-
auto dist = std::uniform_int_distribution<T>{0, (T)runs-1};
27-
auto r = std::vector<T>(runs);
26+
auto dist = std::uniform_int_distribution<T>{0, (T) runs - 1};
27+
auto r = std::vector<T>(runs);
2828
std::generate_n(r.begin(), runs, std::bind(dist, engine));
2929
return r;
3030
}
3131

3232
template <typename Generator, typename Set>
3333
auto benchmark_access_std()
3434
{
35-
return [] (nonius::chronometer meter)
36-
{
35+
return [](nonius::chronometer meter) {
3736
auto n = meter.param<N>();
3837
auto g1 = Generator{}(n);
3938
auto g2 = make_generator_ranged(n);
@@ -55,9 +54,8 @@ auto benchmark_access_std()
5554
template <typename Generator, typename Set>
5655
auto benchmark_access_hamt()
5756
{
58-
return [] (nonius::chronometer meter)
59-
{
60-
auto n = meter.param<N>();
57+
return [](nonius::chronometer meter) {
58+
auto n = meter.param<N>();
6159
auto g1 = Generator{}(n);
6260
auto g2 = make_generator_ranged(n);
6361

@@ -68,7 +66,7 @@ auto benchmark_access_hamt()
6866
measure(meter, [&] {
6967
auto c = 0u;
7068
for (auto i = 0u; i < n; ++i) {
71-
auto& x = g1[g2[i]];
69+
auto& x = g1[g2[i]];
7270
auto leaf = v.find(x).leaf();
7371
c += !!(leaf && leaf->find(x));
7472
}
@@ -78,13 +76,11 @@ auto benchmark_access_hamt()
7876
};
7977
}
8078

81-
8279
template <typename Generator, typename Set>
8380
auto benchmark_access()
8481
{
85-
return [] (nonius::chronometer meter)
86-
{
87-
auto n = meter.param<N>();
82+
return [](nonius::chronometer meter) {
83+
auto n = meter.param<N>();
8884
auto g1 = Generator{}(n);
8985
auto g2 = make_generator_ranged(n);
9086

@@ -105,10 +101,9 @@ auto benchmark_access()
105101
template <typename Generator, typename Set>
106102
auto benchmark_bad_access_std()
107103
{
108-
return [] (nonius::chronometer meter)
109-
{
110-
auto n = meter.param<N>();
111-
auto g1 = Generator{}(n*2);
104+
return [](nonius::chronometer meter) {
105+
auto n = meter.param<N>();
106+
auto g1 = Generator{}(n * 2);
112107

113108
auto v = Set{};
114109
for (auto i = 0u; i < n; ++i)
@@ -117,7 +112,7 @@ auto benchmark_bad_access_std()
117112
measure(meter, [&] {
118113
auto c = 0u;
119114
for (auto i = 0u; i < n; ++i)
120-
c += v.count(g1[n+i]);
115+
c += v.count(g1[n + i]);
121116
volatile auto r = c;
122117
return r;
123118
});
@@ -127,10 +122,9 @@ auto benchmark_bad_access_std()
127122
template <typename Generator, typename Set>
128123
auto benchmark_bad_access_hamt()
129124
{
130-
return [] (nonius::chronometer meter)
131-
{
132-
auto n = meter.param<N>();
133-
auto g1 = Generator{}(n*2);
125+
return [](nonius::chronometer meter) {
126+
auto n = meter.param<N>();
127+
auto g1 = Generator{}(n * 2);
134128

135129
auto v = Set{};
136130
for (auto i = 0u; i < n; ++i)
@@ -139,7 +133,7 @@ auto benchmark_bad_access_hamt()
139133
measure(meter, [&] {
140134
auto c = 0u;
141135
for (auto i = 0u; i < n; ++i) {
142-
auto& x = g1[n+i];
136+
auto& x = g1[n + i];
143137
auto leaf = v.find(x).leaf();
144138
c += !!(leaf && leaf->find(x));
145139
}
@@ -149,14 +143,12 @@ auto benchmark_bad_access_hamt()
149143
};
150144
}
151145

152-
153146
template <typename Generator, typename Set>
154147
auto benchmark_bad_access()
155148
{
156-
return [] (nonius::chronometer meter)
157-
{
158-
auto n = meter.param<N>();
159-
auto g1 = Generator{}(n*2);
149+
return [](nonius::chronometer meter) {
150+
auto n = meter.param<N>();
151+
auto g1 = Generator{}(n * 2);
160152

161153
auto v = Set{};
162154
for (auto i = 0u; i < n; ++i)
@@ -165,7 +157,7 @@ auto benchmark_bad_access()
165157
measure(meter, [&] {
166158
auto c = 0u;
167159
for (auto i = 0u; i < n; ++i)
168-
c += v.count(g1[n+i]);
160+
c += v.count(g1[n + i]);
169161
volatile auto r = c;
170162
return r;
171163
});

‎benchmark/set/iter.hpp

+13-19
Original file line numberDiff line numberDiff line change
@@ -10,30 +10,27 @@
1010

1111
#include "benchmark/config.hpp"
1212

13-
#include <immer/set.hpp>
14-
#include <immer/box.hpp>
15-
#include <immer/algorithm.hpp>
16-
#include <hash_trie.hpp> // Phil Nash
1713
#include <boost/container/flat_set.hpp>
14+
#include <hash_trie.hpp> // Phil Nash
15+
#include <immer/algorithm.hpp>
16+
#include <immer/box.hpp>
17+
#include <immer/set.hpp>
18+
#include <numeric>
1819
#include <set>
1920
#include <unordered_set>
20-
#include <numeric>
2121

2222
namespace {
2323

2424
template <typename T>
2525
struct iter_step
2626
{
27-
unsigned operator() (unsigned x, const T& y) const
28-
{
29-
return x + y;
30-
}
27+
unsigned operator()(unsigned x, const T& y) const { return x + y; }
3128
};
3229

3330
template <>
3431
struct iter_step<std::string>
3532
{
36-
unsigned operator() (unsigned x, const std::string& y) const
33+
unsigned operator()(unsigned x, const std::string& y) const
3734
{
3835
return x + (unsigned) y.size();
3936
}
@@ -42,7 +39,7 @@ struct iter_step<std::string>
4239
template <>
4340
struct iter_step<immer::box<std::string>>
4441
{
45-
unsigned operator() (unsigned x, const immer::box<std::string>& y) const
42+
unsigned operator()(unsigned x, const immer::box<std::string>& y) const
4643
{
4744
return x + (unsigned) y->size();
4845
}
@@ -51,8 +48,7 @@ struct iter_step<immer::box<std::string>>
5148
template <typename Generator, typename Set>
5249
auto benchmark_access_std_iter()
5350
{
54-
return [] (nonius::chronometer meter)
55-
{
51+
return [](nonius::chronometer meter) {
5652
auto n = meter.param<N>();
5753
auto g1 = Generator{}(n);
5854

@@ -71,9 +67,8 @@ auto benchmark_access_std_iter()
7167
template <typename Generator, typename Set>
7268
auto benchmark_access_reduce()
7369
{
74-
return [] (nonius::chronometer meter)
75-
{
76-
auto n = meter.param<N>();
70+
return [](nonius::chronometer meter) {
71+
auto n = meter.param<N>();
7772
auto g1 = Generator{}(n);
7873

7974
auto v = Set{};
@@ -91,9 +86,8 @@ auto benchmark_access_reduce()
9186
template <typename Generator, typename Set>
9287
auto benchmark_access_iter()
9388
{
94-
return [] (nonius::chronometer meter)
95-
{
96-
auto n = meter.param<N>();
89+
return [](nonius::chronometer meter) {
90+
auto n = meter.param<N>();
9791
auto g1 = Generator{}(n);
9892

9993
auto v = Set{};

0 commit comments

Comments
 (0)