From bbd6f91e5fafd7f9180edd571a5be843023ef3be Mon Sep 17 00:00:00 2001 From: sale Date: Tue, 22 Nov 2016 10:24:20 +0000 Subject: [PATCH 1/7] Added benchmark test for QueryStripper; Fixed timer bug Summary: Added benchmark for QueryStripper; Fixed Timer bug; Test Plan: manual Reviewers: buda Subscribers: buda Maniphest Tasks: T100 Differential Revision: https://memgraph.phacility.com/D5 --- include/utils/time/timer.hpp | 1 + tests/benchmark/CMakeLists.txt | 4 ++ tests/benchmark/stripper.cpp | 44 +++++++++++++++++++ .../cypher_queries/stripper/query_dict.yaml | 42 ++++++++++++++++++ 4 files changed, 91 insertions(+) create mode 100644 tests/benchmark/stripper.cpp create mode 100644 tests/data/cypher_queries/stripper/query_dict.yaml diff --git a/include/utils/time/timer.hpp b/include/utils/time/timer.hpp index e8332c5b3..e989ba600 100644 --- a/include/utils/time/timer.hpp +++ b/include/utils/time/timer.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include diff --git a/tests/benchmark/CMakeLists.txt b/tests/benchmark/CMakeLists.txt index ef94ffd2c..a30271887 100644 --- a/tests/benchmark/CMakeLists.txt +++ b/tests/benchmark/CMakeLists.txt @@ -12,6 +12,10 @@ foreach(ONE_BENCH_CPP ${ALL_BENCH_CPP}) add_executable(${TARGET_NAME} ${ONE_BENCH_CPP}) set_target_properties(${TARGET_NAME} PROPERTIES OUTPUT_NAME ${ONE_BENCH_EXEC}) target_link_libraries(${TARGET_NAME} benchmark ${CMAKE_THREAD_LIBS_INIT}) + target_link_libraries(${TARGET_NAME} memgraph) + target_link_libraries(${TARGET_NAME} ${fmt_static_lib}) + target_link_libraries(${TARGET_NAME} Threads::Threads) + target_link_libraries(${TARGET_NAME} ${yaml_static_lib}) add_test(${TARGET_NAME} ${ONE_BENCH_EXEC}) endforeach() diff --git a/tests/benchmark/stripper.cpp b/tests/benchmark/stripper.cpp new file mode 100644 index 000000000..9a9caffb9 --- /dev/null +++ b/tests/benchmark/stripper.cpp @@ -0,0 +1,44 @@ +#include "logging/default.hpp" +#include "logging/streams/stdout.hpp" +#include "utils/time/timer.hpp" +#include "query/preprocesor.hpp" + +#include "benchmark/benchmark_api.h" +#include "yaml-cpp/yaml.h" + +auto BM_Strip = [](benchmark::State& state, auto& function, std::string query) { + while (state.KeepRunning()) { + for (int start = 0; start < state.range(0); start++) { + function(query); + } + } + state.SetComplexityN(state.range(0)); +}; + +int main(int argc, char** argv) { + logging::init_async(); + logging::log->pipe(std::make_unique()); + + YAML::Node dataset = YAML::LoadFile( + "../../tests/data/cypher_queries/stripper/query_dict.yaml"); + + QueryPreprocessor processor; + using std::placeholders::_1; + std::function preprocess = + std::bind(&QueryPreprocessor::preprocess, &processor, _1); + + auto tests = dataset["benchmark_queries"].as>(); + for (auto& test : tests) { + auto* benchmark = + benchmark::RegisterBenchmark(test.c_str(), BM_Strip, preprocess, test) + ->RangeMultiplier(2) + ->Range(1, 8 << 10) + ->Complexity(benchmark::oN); + ; + } + + benchmark::Initialize(&argc, argv); + benchmark::RunSpecifiedBenchmarks(); + + return 0; +} diff --git a/tests/data/cypher_queries/stripper/query_dict.yaml b/tests/data/cypher_queries/stripper/query_dict.yaml new file mode 100644 index 000000000..549733ce4 --- /dev/null +++ b/tests/data/cypher_queries/stripper/query_dict.yaml @@ -0,0 +1,42 @@ +benchmark_queries: + - "MATCH (a) RETURN size(collect(a))" + + - "CREATE (a:L), (b1), (b2) CREATE (a)-[:A]->(b1), (a)-[:A]->(b2)" + + - "MATCH (a:L)-[rel]->(b) RETURN a, count(*)" + + - "CREATE ({division: 'Sweden'})" + + - "MATCH (n) RETURN n.division, count(*) ORDER BY count(*) DESC, n.division ASC" + + - "UNWIND ['a', 'b', 'B', null, 'abc', 'abc1'] AS i RETURN max(i)" + + - "CREATE ({created: true})" + + - "MATCH (a)-[r]-(b) DELETE r, a, b RETURN count(*) AS c" + + - "MATCH (u:User) WITH {key: u} AS nodes DELETE nodes.key" + + - "CREATE ()-[:T {id: 42, alive: true, name: kifla, height=4.2}]->()" + + - "MATCH p = ()-[r:T]-() WHERE r.id = 42 DELETE r" + + - "UNWIND range(0, 1000) AS i CREATE (:A {id: i}) MERGE (:B {id: i % 10})" + + - "MATCH (n) WHERE NOT(n.name = 'apa' AND false) RETURN n" + + - "CREATE ()-[:REL {property1: 12, property2: 24}]->()" + + - "MATCH (n:A) WHERE n.name = 'Andres' SET n.name = 'Michael' RETURN n" + + - "MATCH (n:A) SET (n).name = 'memgraph' RETURN n" + + - "CREATE (a {foo: [1, 2, 3]}) SET a.foo = a.foo + [4, 5] RETURN a.foo" + + - "MATCH (n:X {foo: 'A'}) SET n = {foo: 'B', baz: 'C'} RETURN n" + + - "MATCH (n:X {foo: 'A'}) SET n += {foo: null} RETURN n" + + - "MATCH (n) WITH n LIMIT toInteger(ceil(1.7)) RETURN count(*) AS count" + + - "MATCH (a:A), (b:B) MERGE (a)-[r:TYPE]->(b) ON CREATE SET r.name = 'Lola' RETURN count(r)" From 5a8a7bea65fbc6e636f3608b26ec1d7639627718 Mon Sep 17 00:00:00 2001 From: sale Date: Tue, 22 Nov 2016 16:32:30 +0000 Subject: [PATCH 2/7] Added basic random utility --- include/utils/random/generator.h | 76 ++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 include/utils/random/generator.h diff --git a/include/utils/random/generator.h b/include/utils/random/generator.h new file mode 100644 index 000000000..bc2140068 --- /dev/null +++ b/include/utils/random/generator.h @@ -0,0 +1,76 @@ +#include +#include + +// namespace ::utils +namespace utils { + +// namespace utils::random +namespace random { + +template +class RandomGenerator { + private: + std::random_device device_; + + protected: + Generator gen_; + Distribution dist_; + + public: + RandomGenerator(Distribution dist) : gen_(device_()), dist_(dist) {} + +}; + +class StringGenerator + : public RandomGenerator, + std::default_random_engine> { + public: + StringGenerator() + : RandomGenerator(std::uniform_int_distribution(32, 126)) {} + + std::string next(int size) { + std::string random_string; + + for (int i = 0; i < size; i++) random_string += (dist_(gen_) + '\0'); + return random_string; + } + +}; + +template +class IntegerGenerator : public RandomGenerator { + + public: + IntegerGenerator(DistributionRangeType start, DistributionRangeType end) : + RandomGenerator(Distribution(start, end)){} + + int next() { + return this->dist_(this->gen_); + + } + +}; + +template +class DecimalGenerator : public RandomGenerator { + + public: + DecimalGenerator(DistributionRangeType start, DistributionRangeType end) : + RandomGenerator(Distribution(start, end)) {} + + auto next() { + return this->dist_(this->gen_); + } + +}; + +template +auto generate_vector(RandomGenerator& gen, int size) { + std::vector elements(size); + for (int i = 0; i < size; i++) + elements[i] = gen.next(); + return elements; +} + +}; // namespace utils::random +}; // namespace ::utils From 09edde8572a83fbd44fd77ba70fbe9be928fe46d Mon Sep 17 00:00:00 2001 From: sale Date: Tue, 22 Nov 2016 16:37:21 +0000 Subject: [PATCH 3/7] T101 Summary: Created Basic Random Utility; Created folder for benchmark query stripper Test Plan: manual Reviewers: buda Subscribers: buda Differential Revision: https://memgraph.phacility.com/D6 --- tests/benchmark/stripper.cpp | 44 ------------------------------------ 1 file changed, 44 deletions(-) delete mode 100644 tests/benchmark/stripper.cpp diff --git a/tests/benchmark/stripper.cpp b/tests/benchmark/stripper.cpp deleted file mode 100644 index 9a9caffb9..000000000 --- a/tests/benchmark/stripper.cpp +++ /dev/null @@ -1,44 +0,0 @@ -#include "logging/default.hpp" -#include "logging/streams/stdout.hpp" -#include "utils/time/timer.hpp" -#include "query/preprocesor.hpp" - -#include "benchmark/benchmark_api.h" -#include "yaml-cpp/yaml.h" - -auto BM_Strip = [](benchmark::State& state, auto& function, std::string query) { - while (state.KeepRunning()) { - for (int start = 0; start < state.range(0); start++) { - function(query); - } - } - state.SetComplexityN(state.range(0)); -}; - -int main(int argc, char** argv) { - logging::init_async(); - logging::log->pipe(std::make_unique()); - - YAML::Node dataset = YAML::LoadFile( - "../../tests/data/cypher_queries/stripper/query_dict.yaml"); - - QueryPreprocessor processor; - using std::placeholders::_1; - std::function preprocess = - std::bind(&QueryPreprocessor::preprocess, &processor, _1); - - auto tests = dataset["benchmark_queries"].as>(); - for (auto& test : tests) { - auto* benchmark = - benchmark::RegisterBenchmark(test.c_str(), BM_Strip, preprocess, test) - ->RangeMultiplier(2) - ->Range(1, 8 << 10) - ->Complexity(benchmark::oN); - ; - } - - benchmark::Initialize(&argc, argv); - benchmark::RunSpecifiedBenchmarks(); - - return 0; -} From 1c3cf9c401ba02fd1d289f8d8de8d719cf68eba3 Mon Sep 17 00:00:00 2001 From: sale Date: Tue, 22 Nov 2016 16:42:24 +0000 Subject: [PATCH 4/7] Stripper becnhmark moved to another folder --- tests/benchmark/query/strip/stripper.cpp | 44 ++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 tests/benchmark/query/strip/stripper.cpp diff --git a/tests/benchmark/query/strip/stripper.cpp b/tests/benchmark/query/strip/stripper.cpp new file mode 100644 index 000000000..9a9caffb9 --- /dev/null +++ b/tests/benchmark/query/strip/stripper.cpp @@ -0,0 +1,44 @@ +#include "logging/default.hpp" +#include "logging/streams/stdout.hpp" +#include "utils/time/timer.hpp" +#include "query/preprocesor.hpp" + +#include "benchmark/benchmark_api.h" +#include "yaml-cpp/yaml.h" + +auto BM_Strip = [](benchmark::State& state, auto& function, std::string query) { + while (state.KeepRunning()) { + for (int start = 0; start < state.range(0); start++) { + function(query); + } + } + state.SetComplexityN(state.range(0)); +}; + +int main(int argc, char** argv) { + logging::init_async(); + logging::log->pipe(std::make_unique()); + + YAML::Node dataset = YAML::LoadFile( + "../../tests/data/cypher_queries/stripper/query_dict.yaml"); + + QueryPreprocessor processor; + using std::placeholders::_1; + std::function preprocess = + std::bind(&QueryPreprocessor::preprocess, &processor, _1); + + auto tests = dataset["benchmark_queries"].as>(); + for (auto& test : tests) { + auto* benchmark = + benchmark::RegisterBenchmark(test.c_str(), BM_Strip, preprocess, test) + ->RangeMultiplier(2) + ->Range(1, 8 << 10) + ->Complexity(benchmark::oN); + ; + } + + benchmark::Initialize(&argc, argv); + benchmark::RunSpecifiedBenchmarks(); + + return 0; +} From 8916b774182cba33a8a8e833b30ec8635b1a184e Mon Sep 17 00:00:00 2001 From: sale Date: Tue, 22 Nov 2016 16:46:31 +0000 Subject: [PATCH 5/7] Clang-Formated utils/random/generator.h --- include/utils/random/generator.h | 35 ++++++++------------------------ 1 file changed, 8 insertions(+), 27 deletions(-) diff --git a/include/utils/random/generator.h b/include/utils/random/generator.h index bc2140068..b503e7635 100644 --- a/include/utils/random/generator.h +++ b/include/utils/random/generator.h @@ -18,7 +18,6 @@ class RandomGenerator { public: RandomGenerator(Distribution dist) : gen_(device_()), dist_(dist) {} - }; class StringGenerator @@ -30,45 +29,27 @@ class StringGenerator std::string next(int size) { std::string random_string; + random_string.reserve(size); for (int i = 0; i < size; i++) random_string += (dist_(gen_) + '\0'); + return random_string; } - }; template -class IntegerGenerator : public RandomGenerator { - +class NumberGenerator : public RandomGenerator { public: - IntegerGenerator(DistributionRangeType start, DistributionRangeType end) : - RandomGenerator(Distribution(start, end)){} - - int next() { - return this->dist_(this->gen_); - - } - -}; - -template -class DecimalGenerator : public RandomGenerator { - - public: - DecimalGenerator(DistributionRangeType start, DistributionRangeType end) : - RandomGenerator(Distribution(start, end)) {} - - auto next() { - return this->dist_(this->gen_); - } + NumberGenerator(DistributionRangeType start, DistributionRangeType end) + : RandomGenerator(Distribution(start, end)) {} + auto next() { return this->dist_(this->gen_); } }; template auto generate_vector(RandomGenerator& gen, int size) { - std::vector elements(size); - for (int i = 0; i < size; i++) - elements[i] = gen.next(); + std::vector elements(size); + for (int i = 0; i < size; i++) elements[i] = gen.next(); return elements; } From 0a56df3ddf07fb7ed84afb32d4f79961579896da Mon Sep 17 00:00:00 2001 From: sale Date: Wed, 23 Nov 2016 13:33:52 +0000 Subject: [PATCH 6/7] Added benchmark test for ConcurrentMap; Added PairRandomGenerator to utils; Summary: Added Benchmark Test for ConcurrentMap; Added PairGenerator to utils::random Test Plan: manual Reviewers: buda Subscribers: buda Differential Revision: https://memgraph.phacility.com/D7 --- include/utils/random/generator.h | 24 +- .../concurrent/concurrent_map.cpp | 224 ++++++++++++++++++ 2 files changed, 246 insertions(+), 2 deletions(-) create mode 100644 tests/benchmark/data_structures/concurrent/concurrent_map.cpp diff --git a/include/utils/random/generator.h b/include/utils/random/generator.h index b503e7635..a6313a77c 100644 --- a/include/utils/random/generator.h +++ b/include/utils/random/generator.h @@ -23,9 +23,12 @@ class RandomGenerator { class StringGenerator : public RandomGenerator, std::default_random_engine> { + private: + int size_; public: - StringGenerator() - : RandomGenerator(std::uniform_int_distribution(32, 126)) {} + StringGenerator(int size) + : RandomGenerator(std::uniform_int_distribution(32, 126)), +size_(size) {} std::string next(int size) { std::string random_string; @@ -35,6 +38,10 @@ class StringGenerator return random_string; } + + std::string next() { + return next(size_); + } }; template @@ -46,6 +53,19 @@ class NumberGenerator : public RandomGenerator { auto next() { return this->dist_(this->gen_); } }; +template +class PairGenerator { + private: + FirstGenerator* first_; + SecondGenerator* second_; + public: + PairGenerator(FirstGenerator* first, SecondGenerator* second) : + first_(first), second_(second) {} + auto next() { + return std::make_pair(first_->next(), second_->next()); + } +}; + template auto generate_vector(RandomGenerator& gen, int size) { std::vector elements(size); diff --git a/tests/benchmark/data_structures/concurrent/concurrent_map.cpp b/tests/benchmark/data_structures/concurrent/concurrent_map.cpp new file mode 100644 index 000000000..56ad6f7de --- /dev/null +++ b/tests/benchmark/data_structures/concurrent/concurrent_map.cpp @@ -0,0 +1,224 @@ +#include +#include + +#include "data_structures/concurrent/concurrent_map.hpp" +#include "logging/default.hpp" +#include "logging/streams/stdout.hpp" +#include "utils/random/generator.h" + +#include "benchmark/benchmark_api.h" + +/* + ConcurrentMap Benchmark Test: + - tests time of Insertion, Contain and Delete operations + + - benchmarking time per operation + + - test run ConcurrentMap with the following keys and values: + - + - + - + - + + - tests run single and multi threaded in range (1, Max_Threads_Per_Cpu) + + TODO(sale) implements configurable command line arguments on start +*/ + +using utils::random::NumberGenerator; +using utils::random::PairGenerator; +using utils::random::StringGenerator; + +using IntegerGenerator = NumberGenerator, + std::default_random_engine, int>; + + +template +static void InsertValue(benchmark::State& state, ConcurrentMap* map, + const std::vector>& elements) { + while (state.KeepRunning()) { + auto accessor = map->access(); + for (int start = 0; start < state.range(0); start++) { + accessor.insert(elements[start].first, elements[start].second); + } + } + state.SetComplexityN(state.range(0)); +} + + +template +static void DeleteValue(benchmark::State& state, ConcurrentMap* map, + const std::vector> elements) { + while (state.KeepRunning()) { + auto accessor = map->access(); + for (int start = 0; start < state.range(0); start++) { + accessor.remove(elements[start].first); + } + } + state.SetComplexityN(state.range(0)); +} + + +template +static void ContainsValue(benchmark::State& state, ConcurrentMap* map, + const std::vector> elements) { + while (state.KeepRunning()) { + auto accessor = map->access(); + for (int start = 0; start < state.range(0); start++) { + accessor.contains(elements[start].first); + } + } + state.SetComplexityN(state.range(0)); +} + +auto BM_InsertValue = [](benchmark::State& state, auto* map, auto& elements) { + InsertValue(state, map, elements); +}; + +auto BM_DeleteValue = [](benchmark::State& state, auto* map, auto elements) { + DeleteValue(state, map, elements); +}; + +auto BM_ContainsValue = [](benchmark::State& state, auto* map, auto elements) { + ContainsValue(state, map, elements); +}; + +int main(int argc, char** argv) { + int MAX_ELEMENTS = 1 << 14; + int MULTIPLIER = 2; + int MAX_THREADS = (int)std::thread::hardware_concurrency(); + + logging::init_async(); + logging::log->pipe(std::make_unique()); + + StringGenerator sg(128); + IntegerGenerator ig(0, 1000000); + + /* + Creates RandomGenerators, ConcurentMaps and Random Element Vectors for the + following use cases: + + Map elements contain keys and value for: + , + + + + */ + + PairGenerator piig(&ig, &ig); + PairGenerator pssg(&sg, &sg); + PairGenerator psig(&sg, &ig); + PairGenerator pisg(&ig, &sg); + + ConcurrentMap ii_map; + ConcurrentMap is_map; + ConcurrentMap si_map; + ConcurrentMap ss_map; + + auto ii_elems = utils::random::generate_vector(piig, MAX_ELEMENTS); + auto is_elems = utils::random::generate_vector(pisg, MAX_ELEMENTS); + auto si_elems = utils::random::generate_vector(psig, MAX_ELEMENTS); + auto ss_elems = utils::random::generate_vector(pssg, MAX_ELEMENTS); + + /* insertion Tests */ + + for (int t = 1; t <= MAX_THREADS; t *= 2) { + benchmark::RegisterBenchmark("InsertValue[Int, Int]", BM_InsertValue, + &ii_map, ii_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark("InsertValue[Int, String] (size:128 chars)", + BM_InsertValue, &is_map, is_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark("InsertValue[String, Int] (size:128 chars)", + BM_InsertValue, &si_map, si_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark("InsertValue[String, String] (size:128 chars)", + BM_InsertValue, &ss_map, ss_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + } + + // Contains Benchmark Tests + + for (int t = 1; t <= MAX_THREADS; t *= 2) { + benchmark::RegisterBenchmark("ContainsValue[Int, Int]", BM_ContainsValue, + &ii_map, ii_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark("ContainsValue[Int, String] (size:128 chars)", + BM_ContainsValue, &is_map, is_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark("ContainsValue[String, Int] (size:128 chars)", + BM_ContainsValue, &si_map, si_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark( + "ContainsValue[String, String] (size:128 chars)", BM_ContainsValue, + &ss_map, ss_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + } + + // Deletion Banchamark Tests + + for (int t = 1; t <= MAX_THREADS; t *= 2) { + benchmark::RegisterBenchmark("DeleteValue[Int, Int]", BM_DeleteValue, + &ii_map, ii_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark("DeleteValue[Int, String] (size:128 chars)", + BM_DeleteValue, &is_map, is_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark("DeleteValue[String, Int] (size:128 chars)", + BM_DeleteValue, &si_map, si_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + + benchmark::RegisterBenchmark("DeleteValue[String, String] (size:128 chars)", + BM_DeleteValue, &ss_map, ss_elems) + ->RangeMultiplier(MULTIPLIER) + ->Range(1, MAX_ELEMENTS) + ->Complexity(benchmark::oN) + ->Threads(t); + } + + benchmark::Initialize(&argc, argv); + benchmark::RunSpecifiedBenchmarks(); + + return 0; +} From d8a82b45fc5da52073882960ab6142de275cf93c Mon Sep 17 00:00:00 2001 From: sale Date: Wed, 23 Nov 2016 13:47:52 +0000 Subject: [PATCH 7/7] Runned clang-format over concurrent_map benchmark test and random::utils::generator --- include/utils/random/generator.h | 28 +++++++++---------- .../concurrent/concurrent_map.cpp | 11 +++----- 2 files changed, 17 insertions(+), 22 deletions(-) diff --git a/include/utils/random/generator.h b/include/utils/random/generator.h index a6313a77c..bf110a99a 100644 --- a/include/utils/random/generator.h +++ b/include/utils/random/generator.h @@ -24,11 +24,12 @@ class StringGenerator : public RandomGenerator, std::default_random_engine> { private: - int size_; + int size_; + public: StringGenerator(int size) : RandomGenerator(std::uniform_int_distribution(32, 126)), -size_(size) {} + size_(size) {} std::string next(int size) { std::string random_string; @@ -39,9 +40,7 @@ size_(size) {} return random_string; } - std::string next() { - return next(size_); - } + std::string next() { return next(size_); } }; template @@ -55,19 +54,18 @@ class NumberGenerator : public RandomGenerator { template class PairGenerator { - private: - FirstGenerator* first_; - SecondGenerator* second_; - public: - PairGenerator(FirstGenerator* first, SecondGenerator* second) : - first_(first), second_(second) {} - auto next() { - return std::make_pair(first_->next(), second_->next()); - } + private: + FirstGenerator *first_; + SecondGenerator *second_; + + public: + PairGenerator(FirstGenerator *first, SecondGenerator *second) + : first_(first), second_(second) {} + auto next() { return std::make_pair(first_->next(), second_->next()); } }; template -auto generate_vector(RandomGenerator& gen, int size) { +auto generate_vector(RandomGenerator &gen, int size) { std::vector elements(size); for (int i = 0; i < size; i++) elements[i] = gen.next(); return elements; diff --git a/tests/benchmark/data_structures/concurrent/concurrent_map.cpp b/tests/benchmark/data_structures/concurrent/concurrent_map.cpp index 56ad6f7de..6b4da1c3f 100644 --- a/tests/benchmark/data_structures/concurrent/concurrent_map.cpp +++ b/tests/benchmark/data_structures/concurrent/concurrent_map.cpp @@ -11,18 +11,18 @@ /* ConcurrentMap Benchmark Test: - tests time of Insertion, Contain and Delete operations - + - benchmarking time per operation - + - test run ConcurrentMap with the following keys and values: - - - - - + - tests run single and multi threaded in range (1, Max_Threads_Per_Cpu) - TODO(sale) implements configurable command line arguments on start + TODO(sale) implements configurable command line arguments on start */ using utils::random::NumberGenerator; @@ -32,7 +32,6 @@ using utils::random::StringGenerator; using IntegerGenerator = NumberGenerator, std::default_random_engine, int>; - template static void InsertValue(benchmark::State& state, ConcurrentMap* map, const std::vector>& elements) { @@ -45,7 +44,6 @@ static void InsertValue(benchmark::State& state, ConcurrentMap* map, state.SetComplexityN(state.range(0)); } - template static void DeleteValue(benchmark::State& state, ConcurrentMap* map, const std::vector> elements) { @@ -58,7 +56,6 @@ static void DeleteValue(benchmark::State& state, ConcurrentMap* map, state.SetComplexityN(state.range(0)); } - template static void ContainsValue(benchmark::State& state, ConcurrentMap* map, const std::vector> elements) {