MassiveAtoms/hashmap-bench
2
1
Fork 1
Code Issues Pull Requests Releases Wiki Activity

MOREOPTIONS

Browse Source
This commit is contained in:
TinyAtoms
2020-02-07 15:20:35 -03:00
parent 8536056157
commit 4941fd617a
3 changed files with 281 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/includes/aggregate_tests.h
View File

@@ -7,8 +7,8 @@
vector<int> sizes = {
50000, 100000, 150000, 200000, 250000, 300000, 350000, 400000, 500000,
600000, 700000, 800000, 900000, 1000000,
// 2000000, 3000000, 4000000, 5000000, 6000000, 7000000, 8000000, 9000000, 10000000,
// 15000000, 20000000, 25000000, 30000000, 35000000, 40000000, 45000000, 50000000
2000000, 3000000, 4000000, 5000000, 6000000, 7000000, 8000000, 9000000, 10000000,
15000000, 20000000, 25000000, 30000000, 35000000, 40000000, 45000000, 50000000
};
// to print type info
@@ -41,7 +41,7 @@ std::basic_string_view<char> name(T var) {
template<class T>
void int_test_aggregate(T map, int runs) {
void int_test_aggregate(T map, int runs, int maxsize=20000000) {
std::ofstream output{"results.csv", std::ios_base::app};
for (int i = 0; i < runs; ++i) {
string insert = "\nint_insert, '";
@@ -54,6 +54,9 @@ void int_test_aggregate(T map, int runs) {
nosucc_lookup += string{name(map)} + "'";
delet += string{name(map)} + "'";
for (auto size : sizes) {
if (size > maxsize){
break;
}
vector<int> results = int_test(map, size);
insert += ", " + std::to_string(results[0]);
@@ -70,7 +73,7 @@ void int_test_aggregate(T map, int runs) {
template<class T>
void string_test_aggregate(T map, int runs) {
void string_test_aggregate(T map, int runs, int maxsize=20000000) {
std::ofstream output{"results.csv", std::ios_base::app};
for (int i = 0; i < runs; ++i) {
string insert = "\nint_insert, '";
@@ -83,8 +86,12 @@ void string_test_aggregate(T map, int runs) {
nosucc_lookup += string{name(map)} + "'";
delet += string{name(map)} + "'";
for (auto size : sizes) {
if (size > maxsize){
break;
}
vector<int> results = string_test(map, size);
insert += ", " + std::to_string(results[0]);
succ_lookup += ", " + std::to_string(results[1]);
nosucc_lookup += ", " + std::to_string(results[2]);

167
src/main.cpp
View File

@@ -18,84 +18,87 @@ string choicetext = "Select implementation to test: '-i 1 2 3 4' or '-i 1,2,3'.
"8. emilk's emilib:: hashmap(1) \n"
"9. martin's robin_hood:: hashmaps(2) \n";
// default arguments
vector<int> hashmaps = {1, 2, 3, 4, 5, 6, 7, 8, 9};
bool use_abseil_hash = false;
int runs = 1;
int maxsize = 50000000;
int main(int argc, char** argv) {
CLI::App app{"Hashmap benchmarks"};
vector<int> hashmaps = {1, 2, 3, 4, 5, 6, 7, 8, 9};
app.add_option("-i,--implementation", hashmaps, choicetext )->delimiter(',');
bool use_abseil_hash = false;
app.add_option("-a,--abseil", use_abseil_hash, "use absl::Hash, default is false");
int runs = 1;
app.add_option("-r,--runs", runs, "total runs for each map, default is 1");
app.add_option("-m, --maxsize", maxsize, "The max size of the hashmaps to test for. Default is 50 million.");
CLI11_PARSE(app, argc, argv);
time_point<steady_clock> start_test = steady_clock::now();
if (use_abseil_hash) {
for (auto i : hashmaps) {
switch (i) {
case 1: {
int_test_aggregate(std::unordered_map<int, int>{}, runs);
string_test_aggregate(std::unordered_map<string, string>{}, runs);
int_test_aggregate(std::unordered_map<int, int>{}, runs, maxsize);
string_test_aggregate(std::unordered_map<string, string>{}, runs, maxsize);
break;
}
case 2: {
int_test_aggregate(google::sparse_hash_map<int, int>{}, runs);
string_test_aggregate(google::sparse_hash_map<string, string>{}, runs);
int_test_aggregate(google::dense_hash_map<int, int>{}, runs);
string_test_aggregate(google::dense_hash_map<string, string>{}, runs);
int_test_aggregate(google::sparse_hash_map<int, int>{}, runs, maxsize);
string_test_aggregate(google::sparse_hash_map<string, string>{}, runs, maxsize);
int_test_aggregate(google::dense_hash_map<int, int>{}, runs, maxsize);
string_test_aggregate(google::dense_hash_map<string, string>{}, runs, maxsize);
break;
}
case 3: {
int_test_aggregate(absl::node_hash_map<int, int>{}, runs);
string_test_aggregate(absl::node_hash_map<string, string>{}, runs);
int_test_aggregate(absl::flat_hash_map<int, int>{}, runs);
string_test_aggregate(absl::flat_hash_map<string, string>{}, runs);
int_test_aggregate(absl::node_hash_map<int, int>{}, runs, maxsize);
string_test_aggregate(absl::node_hash_map<string, string>{}, runs, maxsize);
int_test_aggregate(absl::flat_hash_map<int, int>{}, runs, maxsize);
string_test_aggregate(absl::flat_hash_map<string, string>{}, runs, maxsize);
break;
}
case 4: {
int_test_aggregate(tsl::sparse_map<int, int>{}, runs);
string_test_aggregate(tsl::sparse_map<string, string>{}, runs);
// int_test_aggregate(tsl::array_map<int, int>{}, runs);
// string_test_aggregate(tsl::array_map<string, string>{}, runs);
// int_test_aggregate(tsl::ordered_map<int, int>{}, runs);
// string_test_aggregate(tsl::ordered_map<string, string>{}, runs);
int_test_aggregate(tsl::robin_map<int, int>{}, runs);
string_test_aggregate(tsl::robin_map<string, string>{}, runs);
int_test_aggregate(tsl::hopscotch_map<int, int>{}, runs);
string_test_aggregate(tsl::hopscotch_map<string, string>{}, runs);
int_test_aggregate(tsl::sparse_map<int, int>{}, runs, maxsize);
string_test_aggregate(tsl::sparse_map<string, string>{}, runs, maxsize);
// int_test_aggregate(tsl::array_map<int, int>{}, runs, maxsize);
// string_test_aggregate(tsl::array_map<string, string>{}, runs, maxsize);
// int_test_aggregate(tsl::ordered_map<int, int>{}, runs, maxsize);
// string_test_aggregate(tsl::ordered_map<string, string>{}, runs, maxsize);
int_test_aggregate(tsl::robin_map<int, int>{}, runs, maxsize);
string_test_aggregate(tsl::robin_map<string, string>{}, runs, maxsize);
int_test_aggregate(tsl::hopscotch_map<int, int>{}, runs, maxsize);
string_test_aggregate(tsl::hopscotch_map<string, string>{}, runs, maxsize);
break;
}
case 5: {
int_test_aggregate(boost::unordered_map<int, int>{}, runs);
string_test_aggregate(boost::unordered_map<string, string>{}, runs);
int_test_aggregate(boost::unordered_map<int, int>{}, runs, maxsize);
string_test_aggregate(boost::unordered_map<string, string>{}, runs, maxsize);
break;
}
case 6: {
int_test_aggregate(ska::unordered_map<int, int>{}, runs);
string_test_aggregate(ska::unordered_map<string, string>{}, runs);
int_test_aggregate(ska::bytell_hash_map<int, int>{}, runs);
string_test_aggregate(ska::bytell_hash_map<string, string>{}, runs);
int_test_aggregate(ska::flat_hash_map<int, int>{}, runs);
string_test_aggregate(ska::flat_hash_map<string, string>{}, runs);
int_test_aggregate(ska::unordered_map<int, int>{}, runs, maxsize);
string_test_aggregate(ska::unordered_map<string, string>{}, runs, maxsize);
int_test_aggregate(ska::bytell_hash_map<int, int>{}, runs, maxsize);
string_test_aggregate(ska::bytell_hash_map<string, string>{}, runs, maxsize);
int_test_aggregate(ska::flat_hash_map<int, int>{}, runs, maxsize);
string_test_aggregate(ska::flat_hash_map<string, string>{}, runs, maxsize);
break;
}
case 7: {
int_test_aggregate(phmap::parallel_flat_hash_map<int, int>{}, runs);
string_test_aggregate(phmap::parallel_flat_hash_map<string, string>{}, runs);
int_test_aggregate(phmap::parallel_node_hash_map<int, int>{}, runs);
string_test_aggregate(phmap::parallel_node_hash_map<string, string>{}, runs);
int_test_aggregate(phmap::parallel_flat_hash_map<int, int>{}, runs, maxsize);
string_test_aggregate(phmap::parallel_flat_hash_map<string, string>{}, runs, maxsize);
int_test_aggregate(phmap::parallel_node_hash_map<int, int>{}, runs, maxsize);
string_test_aggregate(phmap::parallel_node_hash_map<string, string>{}, runs, maxsize);
break;
}
case 8: {
int_test_aggregate(emilib::HashMap<int, int>{}, runs);
string_test_aggregate(emilib::HashMap<string, string>{}, runs);
int_test_aggregate(emilib::HashMap<int, int>{}, runs, maxsize);
string_test_aggregate(emilib::HashMap<string, string>{}, runs, maxsize);
break;
}
case 9: {
int_test_aggregate(robin_hood::unordered_flat_map<int, int>{}, runs);
string_test_aggregate(robin_hood::unordered_flat_map<string, string>{}, runs);
int_test_aggregate(robin_hood::unordered_node_map<int, int>{}, runs);
string_test_aggregate(robin_hood::unordered_node_map<string, string>{}, runs);
int_test_aggregate(robin_hood::unordered_flat_map<int, int>{}, runs, maxsize);
string_test_aggregate(robin_hood::unordered_flat_map<string, string>{}, runs, maxsize);
int_test_aggregate(robin_hood::unordered_node_map<int, int>{}, runs, maxsize);
string_test_aggregate(robin_hood::unordered_node_map<string, string>{}, runs, maxsize);
break;
}
}
@@ -105,69 +108,69 @@ int main(int argc, char** argv) {
for (auto i : hashmaps) {
switch (i) {
case 1: {
int_test_aggregate(std::unordered_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(std::unordered_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(std::unordered_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(std::unordered_map<string, string, Hash<string>>{}, runs, maxsize);
break;
}
case 2: {
int_test_aggregate(google::sparse_hash_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(google::sparse_hash_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(google::dense_hash_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(google::dense_hash_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(google::sparse_hash_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(google::sparse_hash_map<string, string, Hash<string>>{}, runs, maxsize);
int_test_aggregate(google::dense_hash_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(google::dense_hash_map<string, string, Hash<string>>{}, runs, maxsize);
break;
}
case 3: {
int_test_aggregate(absl::node_hash_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(absl::node_hash_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(absl::flat_hash_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(absl::flat_hash_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(absl::node_hash_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(absl::node_hash_map<string, string, Hash<string>>{}, runs, maxsize);
int_test_aggregate(absl::flat_hash_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(absl::flat_hash_map<string, string, Hash<string>>{}, runs, maxsize);
break;
}
case 4: {
int_test_aggregate(tsl::sparse_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(tsl::sparse_map<string, string, Hash<string>>{}, runs);
// int_test_aggregate(tsl::array_map<int, int, Hash<int>>{}, runs);
// string_test_aggregate(tsl::array_map<string, string, Hash<string>>{}, runs);
// int_test_aggregate(tsl::ordered_map<int, int, Hash<int>>{}, runs);
// string_test_aggregate(tsl::ordered_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(tsl::robin_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(tsl::robin_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(tsl::hopscotch_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(tsl::hopscotch_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(tsl::sparse_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(tsl::sparse_map<string, string, Hash<string>>{}, runs, maxsize);
// int_test_aggregate(tsl::array_map<int, int, Hash<int>>{}, runs, maxsize);
// string_test_aggregate(tsl::array_map<string, string, Hash<string>>{}, runs, maxsize);
// int_test_aggregate(tsl::ordered_map<int, int, Hash<int>>{}, runs, maxsize);
// string_test_aggregate(tsl::ordered_map<string, string, Hash<string>>{}, runs, maxsize);
int_test_aggregate(tsl::robin_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(tsl::robin_map<string, string, Hash<string>>{}, runs, maxsize);
int_test_aggregate(tsl::hopscotch_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(tsl::hopscotch_map<string, string, Hash<string>>{}, runs, maxsize);
break;
}
case 5: {
int_test_aggregate(boost::unordered_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(boost::unordered_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(boost::unordered_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(boost::unordered_map<string, string, Hash<string>>{}, runs, maxsize);
break;
}
case 6: {
int_test_aggregate(ska::unordered_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(ska::unordered_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(ska::bytell_hash_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(ska::bytell_hash_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(ska::flat_hash_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(ska::flat_hash_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(ska::unordered_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(ska::unordered_map<string, string, Hash<string>>{}, runs, maxsize);
int_test_aggregate(ska::bytell_hash_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(ska::bytell_hash_map<string, string, Hash<string>>{}, runs, maxsize);
int_test_aggregate(ska::flat_hash_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(ska::flat_hash_map<string, string, Hash<string>>{}, runs, maxsize);
break;
}
case 7: {
int_test_aggregate(phmap::parallel_flat_hash_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(phmap::parallel_flat_hash_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(phmap::parallel_node_hash_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(phmap::parallel_node_hash_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(phmap::parallel_flat_hash_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(phmap::parallel_flat_hash_map<string, string, Hash<string>>{}, runs, maxsize);
int_test_aggregate(phmap::parallel_node_hash_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(phmap::parallel_node_hash_map<string, string, Hash<string>>{}, runs, maxsize);
break;
}
case 8: {
int_test_aggregate(emilib::HashMap<int, int, Hash<int>>{}, runs);
string_test_aggregate(emilib::HashMap<string, string, Hash<string>>{}, runs);
int_test_aggregate(emilib::HashMap<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(emilib::HashMap<string, string, Hash<string>>{}, runs, maxsize);
break;
}
case 9: {
int_test_aggregate(robin_hood::unordered_flat_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(robin_hood::unordered_flat_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(robin_hood::unordered_node_map<int, int, Hash<int>>{}, runs);
string_test_aggregate(robin_hood::unordered_node_map<string, string, Hash<string>>{}, runs);
int_test_aggregate(robin_hood::unordered_flat_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(robin_hood::unordered_flat_map<string, string, Hash<string>>{}, runs, maxsize);
int_test_aggregate(robin_hood::unordered_node_map<int, int, Hash<int>>{}, runs, maxsize);
string_test_aggregate(robin_hood::unordered_node_map<string, string, Hash<string>>{}, runs, maxsize);
break;
}
@@ -177,8 +180,8 @@ int main(int argc, char** argv) {
}
time_point<steady_clock> end_test = steady_clock::now();
std::cout << "\n\n 30 runs for all tests for 1 map: " << duration_cast<seconds>(end_test - start_test).count()
<< " seconds\n\n";
std::cout << "\n\n" << runs << " runs for all tests for " << hashmaps.size() << "maps: "
<< duration_cast<seconds>(end_test - start_test).count() << " seconds\n\n";
}