Skip to content

Commit d3c8eac

Browse files
tzaeschketzaeschke
authored
flat fixed size vector (#124)
1 parent b2b72f5 commit d3c8eac

21 files changed

+1239
-151
lines changed

‎CHANGELOG.md

+3-1
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
55
and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
66

77
## [Unreleased]
8-
Nothing yet.
8+
### Added
9+
- Added `bpt_fixed_vector`, a fixed size flat vector for future use. It can be dropped in for an std::vector.
10+
[#124](https://github.com/tzaeschke/phtree-cpp/pull/124)
911

1012
## [1.5.0] - 2023-02-09
1113
### Added

‎benchmark/bpt_erase_benchmark.cc

+27-11
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,7 @@ enum Scenario {
3333
MULTIMAP,
3434
HASH_MAP,
3535
STD_MAP,
36+
STD_MULTIMAP,
3637
};
3738

3839
using payload_t = int;
@@ -48,7 +49,13 @@ using TestIndex = typename std::conditional_t<
4849
typename std::conditional_t<
4950
SCENARIO == HASH_MAP,
5051
b_plus_tree_hash_map<key_t, payload_t>,
51-
std::map<key_t, payload_t>>>>;
52+
typename std::conditional_t<
53+
SCENARIO == STD_MAP,
54+
std::map<key_t, payload_t>,
55+
typename std::conditional_t<
56+
SCENARIO == STD_MULTIMAP,
57+
std::multimap<key_t, payload_t>,
58+
void>>>>>;
5259

5360
/*
5461
* Benchmark for removing entries.
@@ -125,8 +132,6 @@ template <dimension_t DIM, Scenario TYPE>
125132
void IndexBenchmark<DIM, TYPE>::Remove(benchmark::State& state, Index& tree) {
126133
size_t n = 0;
127134
for (size_t i = 0; i < num_entities_; ++i) {
128-
// n += tree.erase(points_[i][0]);
129-
// TODO
130135
tree.erase(points_[i][0]);
131136
++n;
132137
}
@@ -138,46 +143,57 @@ void IndexBenchmark<DIM, TYPE>::Remove(benchmark::State& state, Index& tree) {
138143
} // namespace
139144

140145
template <typename... Arguments>
141-
void PhTree3D_MAP_REM(benchmark::State& state, Arguments&&... arguments) {
146+
void BPT_MAP_REM(benchmark::State& state, Arguments&&... arguments) {
142147
IndexBenchmark<3, MAP> benchmark{state, arguments...};
143148
benchmark.Benchmark(state);
144149
}
145150

146151
template <typename... Arguments>
147-
void PhTree3D_MM_REM(benchmark::State& state, Arguments&&... arguments) {
152+
void BPT_MM_REM(benchmark::State& state, Arguments&&... arguments) {
148153
IndexBenchmark<3, MULTIMAP> benchmark{state, arguments...};
149154
benchmark.Benchmark(state);
150155
}
151156

152157
template <typename... Arguments>
153-
void PhTree3D_HM_REM(benchmark::State& state, Arguments&&... arguments) {
158+
void BPT_HM_REM(benchmark::State& state, Arguments&&... arguments) {
154159
IndexBenchmark<3, HASH_MAP> benchmark{state, arguments...};
155160
benchmark.Benchmark(state);
156161
}
157162

158163
template <typename... Arguments>
159-
void PhTree3D_STD_MAP_REM(benchmark::State& state, Arguments&&... arguments) {
164+
void STD_MULTIMAP_REM(benchmark::State& state, Arguments&&... arguments) {
165+
IndexBenchmark<3, STD_MULTIMAP> benchmark{state, arguments...};
166+
benchmark.Benchmark(state);
167+
}
168+
169+
template <typename... Arguments>
170+
void STD_MAP_REM(benchmark::State& state, Arguments&&... arguments) {
160171
IndexBenchmark<3, STD_MAP> benchmark{state, arguments...};
161172
benchmark.Benchmark(state);
162173
}
163174

164175
// index type, scenario name, data_generator, num_entities, function_to_call
165-
BENCHMARK_CAPTURE(PhTree3D_MAP_REM, MAP, 0.0)
176+
BENCHMARK_CAPTURE(BPT_MAP_REM, MAP, 0.0)
177+
->RangeMultiplier(10)
178+
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
179+
->Unit(benchmark::kMillisecond);
180+
181+
BENCHMARK_CAPTURE(BPT_MM_REM, MULTIMAP, 0.0)
166182
->RangeMultiplier(10)
167183
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
168184
->Unit(benchmark::kMillisecond);
169185

170-
BENCHMARK_CAPTURE(PhTree3D_MM_REM, MULTIMAP, 0.0)
186+
BENCHMARK_CAPTURE(BPT_HM_REM, HASH_MAP, 0.0)
171187
->RangeMultiplier(10)
172188
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
173189
->Unit(benchmark::kMillisecond);
174190

175-
BENCHMARK_CAPTURE(PhTree3D_HM_REM, HASH_MAP, 0.0)
191+
BENCHMARK_CAPTURE(STD_MULTIMAP_REM, STD_MULTIMAP, 0.0)
176192
->RangeMultiplier(10)
177193
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
178194
->Unit(benchmark::kMillisecond);
179195

180-
BENCHMARK_CAPTURE(PhTree3D_STD_MAP_REM, STD_MAP, 0.0)
196+
BENCHMARK_CAPTURE(STD_MAP_REM, STD_MAP, 0.0)
181197
->RangeMultiplier(10)
182198
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
183199
->Unit(benchmark::kMillisecond);

‎benchmark/bpt_erase_it_benchmark.cc

+27-9
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,7 @@ enum Scenario {
3333
MULTIMAP,
3434
HASH_MAP,
3535
STD_MAP,
36+
STD_MULTIMAP,
3637
};
3738

3839
using payload_t = int;
@@ -48,7 +49,13 @@ using TestIndex = typename std::conditional_t<
4849
typename std::conditional_t<
4950
SCENARIO == HASH_MAP,
5051
b_plus_tree_hash_map<key_t, payload_t>,
51-
std::map<key_t, payload_t>>>>;
52+
typename std::conditional_t<
53+
SCENARIO == STD_MAP,
54+
std::map<key_t, payload_t>,
55+
typename std::conditional_t<
56+
SCENARIO == STD_MULTIMAP,
57+
std::multimap<key_t, payload_t>,
58+
void>>>>>;
5259

5360
/*
5461
* Benchmark for removing entries.
@@ -139,46 +146,57 @@ void IndexBenchmark<DIM, TYPE>::Remove(benchmark::State& state, Index& tree) {
139146
} // namespace
140147

141148
template <typename... Arguments>
142-
void PhTree3D_MAP_REM_IT(benchmark::State& state, Arguments&&... arguments) {
149+
void BPT_MAP_REM_IT(benchmark::State& state, Arguments&&... arguments) {
143150
IndexBenchmark<3, MAP> benchmark{state, arguments...};
144151
benchmark.Benchmark(state);
145152
}
146153

147154
template <typename... Arguments>
148-
void PhTree3D_MM_REM_IT(benchmark::State& state, Arguments&&... arguments) {
155+
void BPT_MM_REM_IT(benchmark::State& state, Arguments&&... arguments) {
149156
IndexBenchmark<3, MULTIMAP> benchmark{state, arguments...};
150157
benchmark.Benchmark(state);
151158
}
152159

153160
template <typename... Arguments>
154-
void PhTree3D_HM_REM_IT(benchmark::State& state, Arguments&&... arguments) {
161+
void BPT_HM_REM_IT(benchmark::State& state, Arguments&&... arguments) {
155162
IndexBenchmark<3, HASH_MAP> benchmark{state, arguments...};
156163
benchmark.Benchmark(state);
157164
}
158165

159166
template <typename... Arguments>
160-
void PhTree3D_STD_MAP_REM_IT(benchmark::State& state, Arguments&&... arguments) {
167+
void STD_MULTIMAP_REM_IT(benchmark::State& state, Arguments&&... arguments) {
168+
IndexBenchmark<3, STD_MULTIMAP> benchmark{state, arguments...};
169+
benchmark.Benchmark(state);
170+
}
171+
172+
template <typename... Arguments>
173+
void STD_MAP_REM_IT(benchmark::State& state, Arguments&&... arguments) {
161174
IndexBenchmark<3, STD_MAP> benchmark{state, arguments...};
162175
benchmark.Benchmark(state);
163176
}
164177

165178
// index type, scenario name, data_generator, num_entities, function_to_call
166-
BENCHMARK_CAPTURE(PhTree3D_MAP_REM_IT, MAP, 0.0)
179+
BENCHMARK_CAPTURE(BPT_MAP_REM_IT, MAP, 0.0)
180+
->RangeMultiplier(10)
181+
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
182+
->Unit(benchmark::kMillisecond);
183+
184+
BENCHMARK_CAPTURE(BPT_MM_REM_IT, MULTIMAP, 0.0)
167185
->RangeMultiplier(10)
168186
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
169187
->Unit(benchmark::kMillisecond);
170188

171-
BENCHMARK_CAPTURE(PhTree3D_MM_REM_IT, MULTIMAP, 0.0)
189+
BENCHMARK_CAPTURE(BPT_HM_REM_IT, HASH_MAP, 0.0)
172190
->RangeMultiplier(10)
173191
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
174192
->Unit(benchmark::kMillisecond);
175193

176-
BENCHMARK_CAPTURE(PhTree3D_HM_REM_IT, HASH_MAP, 0.0)
194+
BENCHMARK_CAPTURE(STD_MULTIMAP_REM_IT, STD_MULTIMAP, 0.0)
177195
->RangeMultiplier(10)
178196
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
179197
->Unit(benchmark::kMillisecond);
180198

181-
BENCHMARK_CAPTURE(PhTree3D_STD_MAP_REM_IT, STD_MAP, 0.0)
199+
BENCHMARK_CAPTURE(STD_MAP_REM_IT, STD_MAP, 0.0)
182200
->RangeMultiplier(10)
183201
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
184202
->Unit(benchmark::kMillisecond);

‎benchmark/bpt_insert_benchmark.cc

+35-29
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,7 @@ enum Scenario {
3333
MULTIMAP,
3434
HASH_MAP,
3535
STD_MAP,
36+
STD_MULTIMAP,
3637
};
3738

3839
using payload_t = int;
@@ -48,7 +49,13 @@ using TestIndex = typename std::conditional_t<
4849
typename std::conditional_t<
4950
SCENARIO == HASH_MAP,
5051
b_plus_tree_hash_map<key_t, payload_t>,
51-
std::map<key_t, payload_t>>>>;
52+
typename std::conditional_t<
53+
SCENARIO == STD_MAP,
54+
std::map<key_t, payload_t>,
55+
typename std::conditional_t<
56+
SCENARIO == STD_MULTIMAP,
57+
std::multimap<key_t, payload_t>,
58+
void>>>>>;
5259

5360
/*
5461
* Benchmark for adding entries to the index.
@@ -110,19 +117,7 @@ void IndexBenchmark<DIM, TYPE>::SetupWorld(benchmark::State& state) {
110117
template <dimension_t DIM, Scenario TYPE>
111118
void IndexBenchmark<DIM, TYPE>::Insert(benchmark::State& state, Index& tree) {
112119
switch (TYPE) {
113-
case MAP: {
114-
for (size_t i = 0; i < num_entities_; ++i) {
115-
tree.emplace(points_[i][0], (payload_t)i);
116-
}
117-
break;
118-
}
119-
case MULTIMAP: {
120-
for (size_t i = 0; i < num_entities_; ++i) {
121-
tree.emplace(points_[i][0], (payload_t)i);
122-
}
123-
break;
124-
}
125-
case HASH_MAP: {
120+
default: {
126121
for (size_t i = 0; i < num_entities_; ++i) {
127122
tree.emplace(points_[i][0], (payload_t)i);
128123
}
@@ -137,79 +132,90 @@ void IndexBenchmark<DIM, TYPE>::Insert(benchmark::State& state, Index& tree) {
137132
} // namespace
138133

139134
template <typename... Arguments>
140-
void PhTree3D_MAP_INS_3(benchmark::State& state, Arguments&&... arguments) {
135+
void BPT_MAP_INS_3D(benchmark::State& state, Arguments&&... arguments) {
141136
IndexBenchmark<3, MAP> benchmark{state, arguments...};
142137
benchmark.Benchmark(state);
143138
}
144139

145140
template <typename... Arguments>
146-
void PhTree4D_MAP_INS_4(benchmark::State& state, Arguments&&... arguments) {
141+
void BPT_MAP_INS_4D(benchmark::State& state, Arguments&&... arguments) {
147142
IndexBenchmark<4, MAP> benchmark{state, arguments...};
148143
benchmark.Benchmark(state);
149144
}
150145

151146
template <typename... Arguments>
152-
void PhTree6D_MAP_INS_6(benchmark::State& state, Arguments&&... arguments) {
147+
void BPT_MAP_INS_6D(benchmark::State& state, Arguments&&... arguments) {
153148
IndexBenchmark<6, MAP> benchmark{state, arguments...};
154149
benchmark.Benchmark(state);
155150
}
156151

157152
template <typename... Arguments>
158-
void PhTree3D_MAP_INS(benchmark::State& state, Arguments&&... arguments) {
153+
void BPT_MAP_INS(benchmark::State& state, Arguments&&... arguments) {
159154
IndexBenchmark<3, MAP> benchmark{state, arguments...};
160155
benchmark.Benchmark(state);
161156
}
162157

163158
template <typename... Arguments>
164-
void PhTree3D_MM_INS(benchmark::State& state, Arguments&&... arguments) {
159+
void BPT_MM_INS(benchmark::State& state, Arguments&&... arguments) {
165160
IndexBenchmark<3, MULTIMAP> benchmark{state, arguments...};
166161
benchmark.Benchmark(state);
167162
}
168163

169164
template <typename... Arguments>
170-
void PhTree3D_HM_INS(benchmark::State& state, Arguments&&... arguments) {
165+
void BPT_HM_INS(benchmark::State& state, Arguments&&... arguments) {
171166
IndexBenchmark<3, HASH_MAP> benchmark{state, arguments...};
172167
benchmark.Benchmark(state);
173168
}
174169

175170
template <typename... Arguments>
176-
void PhTree3D_STD_MAP_INS(benchmark::State& state, Arguments&&... arguments) {
177-
IndexBenchmark<3, HASH_MAP> benchmark{state, arguments...};
171+
void STD_MAP_INS(benchmark::State& state, Arguments&&... arguments) {
172+
IndexBenchmark<3, STD_MAP> benchmark{state, arguments...};
173+
benchmark.Benchmark(state);
174+
}
175+
176+
template <typename... Arguments>
177+
void STD_MULTIMAP_INS(benchmark::State& state, Arguments&&... arguments) {
178+
IndexBenchmark<3, STD_MULTIMAP> benchmark{state, arguments...};
178179
benchmark.Benchmark(state);
179180
}
180181

181182
// index type, scenario name, data_generator, num_entities, function_to_call
182-
BENCHMARK_CAPTURE(PhTree3D_MAP_INS_3, MAP, 0.0)
183+
BENCHMARK_CAPTURE(BPT_MAP_INS_3D, MAP, 0.0)
183184
->RangeMultiplier(2)
184185
->Ranges({{2, 8}, {TestGenerator::CUBE, TestGenerator::CUBE}})
185186
->Unit(benchmark::kMillisecond);
186187

187-
BENCHMARK_CAPTURE(PhTree4D_MAP_INS_4, MAP, 0.0)
188+
BENCHMARK_CAPTURE(BPT_MAP_INS_4D, MAP, 0.0)
188189
->RangeMultiplier(2)
189190
->Ranges({{2, 16}, {TestGenerator::CUBE, TestGenerator::CUBE}})
190191
->Unit(benchmark::kMillisecond);
191192

192-
BENCHMARK_CAPTURE(PhTree6D_MAP_INS_6, MAP, 0.0)
193+
BENCHMARK_CAPTURE(BPT_MAP_INS_6D, MAP, 0.0)
193194
->RangeMultiplier(2)
194195
->Ranges({{2, 32}, {TestGenerator::CUBE, TestGenerator::CUBE}})
195196
->Unit(benchmark::kMillisecond);
196197

197-
BENCHMARK_CAPTURE(PhTree3D_MAP_INS, MAP, 0.0)
198+
BENCHMARK_CAPTURE(BPT_MAP_INS, MAP, 0.0)
199+
->RangeMultiplier(10)
200+
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
201+
->Unit(benchmark::kMillisecond);
202+
203+
BENCHMARK_CAPTURE(BPT_MM_INS, MULTIMAP, 0.0)
198204
->RangeMultiplier(10)
199205
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
200206
->Unit(benchmark::kMillisecond);
201207

202-
BENCHMARK_CAPTURE(PhTree3D_MM_INS, MULTIMAP, 0.0)
208+
BENCHMARK_CAPTURE(BPT_HM_INS, HASH_MAP, 0.0)
203209
->RangeMultiplier(10)
204210
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
205211
->Unit(benchmark::kMillisecond);
206212

207-
BENCHMARK_CAPTURE(PhTree3D_HM_INS, HASH_MAP, 0.0)
213+
BENCHMARK_CAPTURE(STD_MULTIMAP_INS, STD_MULTIMAP, 0.0)
208214
->RangeMultiplier(10)
209215
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
210216
->Unit(benchmark::kMillisecond);
211217

212-
BENCHMARK_CAPTURE(PhTree3D_STD_MAP_INS, STD_MAP, 0.0)
218+
BENCHMARK_CAPTURE(STD_MAP_INS, STD_MAP, 0.0)
213219
->RangeMultiplier(10)
214220
->Ranges({{100, 100 * 1000}, {TestGenerator::CLUSTER, TestGenerator::CUBE}})
215221
->Unit(benchmark::kMillisecond);

0 commit comments

Comments
 (0)