benchmarks_map_insertion/try_emplace.cpp at master · Jiwan/benchmarks_map_insertion · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#include <benchmark/benchmark.h>

#include <algorithm>
#include <memory>
#include <map>
#include <string>
#include <type_traits>
#include <utility>

#include <cstdlib>

template<class T>
struct lazy_convert_construct
{
	using result_type = std::invoke_result_t<T>;

	constexpr lazy_convert_construct(T&& t)
		: t_(std::move(t))
	{

	}

	constexpr inline operator result_type() const noexcept(noexcept(std::declval<T>()()))
	{
		return t_();
	}

	T t_;
};

struct a_costly_type
{
	a_costly_type(int)
	{
		std::generate(std::begin(x), std::end(x), [](){ return std::rand(); });
	}

	int x[1024];
};

const std::string key = "yolololololololololololololololololololoyolololololololololololololololololololo";

template <class T>
void fill_map(std::map<std::string, std::unique_ptr<T>>& m)
{
	auto x = 0;

	for (int i = 0; i < 100000; ++i) {
		x += i;
		auto new_key = key;
		new_key[x % 33] = 'a' + (x % 20);
		m[new_key] = nullptr;
	}
}

void insertion_double_lookup(benchmark::State& state) {
	std::map<std::string, std::unique_ptr<int>> m;
	fill_map(m);

	for (auto _ : state) {
		if (m.find(key) == m.end()) {
			m[key] = std::make_unique<int>(42);
		}

		state.PauseTiming();
		m.erase(key);
		state.ResumeTiming();
	}
}

BENCHMARK(insertion_double_lookup);

void insertion_construct_before_emplace(benchmark::State& state) {
	std::map<std::string, std::unique_ptr<int>> m;
	fill_map(m);

	for (auto _ : state) {
		m.try_emplace(key, std::make_unique<int>(42));
		state.PauseTiming();
		m.erase(key);
		state.ResumeTiming();
	}
}

BENCHMARK(insertion_construct_before_emplace);

void insertion_lazy_convert_try_emplace(benchmark::State& state) {
	std::map<std::string, std::unique_ptr<int>> m;
	fill_map(m);

	for (auto _ : state) {
		m.try_emplace(key, lazy_convert_construct([]{ return std::make_unique<int>(42);} ));
		state.PauseTiming();
		m.erase(key);
		state.ResumeTiming();
	}
}

BENCHMARK(insertion_lazy_convert_try_emplace);

void no_insertion_double_lookup(benchmark::State& state) {
	std::map<std::string, std::unique_ptr<a_costly_type>> m;

	fill_map(m);
	m[key] = nullptr;

	for (auto _ : state) {
		if (m.find(key) == m.end()) {
			m[key] = std::make_unique<a_costly_type>(42);
		}
	}
}

BENCHMARK(no_insertion_double_lookup);

void no_insertion_construct_before_emplace(benchmark::State& state) {
	std::map<std::string, std::unique_ptr<a_costly_type>> m;

	fill_map(m);
	m[key] = nullptr;

	for (auto _ : state) {
		m.try_emplace(key, std::make_unique<a_costly_type>(42));
	}
}

BENCHMARK(no_insertion_construct_before_emplace);

void no_insertion_lazy_convert_try_emplace(benchmark::State& state) {
	std::map<std::string, std::unique_ptr<a_costly_type>> m;

	fill_map(m);
	m[key] = nullptr;

	for (auto _ : state) {
		m.try_emplace(key, lazy_convert_construct([]{ return std::make_unique<a_costly_type>(42);} ));
	}
}

BENCHMARK(no_insertion_lazy_convert_try_emplace);


BENCHMARK_MAIN();