diff options
Diffstat (limited to 'searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp')
-rw-r--r-- | searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp | 391 |
1 files changed, 243 insertions, 148 deletions
diff --git a/searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp b/searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp index 9c084db4a5d..2721f135cfb 100644 --- a/searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp +++ b/searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp @@ -36,7 +36,6 @@ constexpr uint32_t default_seed = 1234; std::mt19937 gen(default_seed); const vespalib::string field = "myfield"; double budget_sec = 1.0; -using DocidVector = std::vector<uint32_t>; BitVector::UP random_docids(uint32_t docid_limit, uint32_t count) @@ -163,9 +162,18 @@ struct BenchmarkResult { double estimate; double cost; vespalib::string iterator_name; - BenchmarkResult() : BenchmarkResult(0, 0, 0, 0, 0, "") {} - BenchmarkResult(double time_ms_in, uint32_t seeks_in, uint32_t hits_in, double estimate_in, double cost_in, const vespalib::string& iterator_name_in) - : time_ms(time_ms_in), seeks(seeks_in), hits(hits_in), estimate(estimate_in), cost(cost_in), iterator_name(iterator_name_in) {} + vespalib::string blueprint_name; + BenchmarkResult() : BenchmarkResult(0, 0, 0, 0, 0, "", "") {} + BenchmarkResult(double time_ms_in, uint32_t seeks_in, uint32_t hits_in, double estimate_in, double cost_in, + const vespalib::string& iterator_name_in, const vespalib::string& blueprint_name_in) + : time_ms(time_ms_in), + seeks(seeks_in), + hits(hits_in), + estimate(estimate_in), + cost(cost_in), + iterator_name(iterator_name_in), + blueprint_name(blueprint_name_in) + {} double ns_per_seek() const { return (time_ms / seeks) * 1000.0 * 1000.0; } double ms_per_cost() const { return (time_ms / cost); } }; @@ -186,12 +194,35 @@ struct Stats { } }; -class BenchmarkResults { +double +calc_median(const std::vector<double>& sorted_values) +{ + size_t middle = sorted_values.size() / 2; + if (sorted_values.size() % 2 == 0) { + return (sorted_values[middle - 1] + sorted_values[middle]) / 2; + } else { + return sorted_values[middle]; + } +} + +double +calc_standard_deviation(const std::vector<double>& values, double average) +{ + double deviations = 0.0; + for (double val : values) { + double diff = val - average; + deviations += (diff * diff); + } + // Bessel's correction (dividing by N-1, instead of N). + double variance = deviations / (values.size() - 1); + return std::sqrt(variance); +} + +class BenchmarkCaseResult { private: std::vector<BenchmarkResult> _results; - template <typename F> - std::vector<double> extract_sorted_values(F func) const { + std::vector<double> extract_sorted_values(auto func) const { std::vector<double> values; for (const auto& res: _results) { values.push_back(func(res)); @@ -200,27 +231,7 @@ private: return values; } - double calc_median(const std::vector<double>& values) const { - size_t middle = values.size() / 2; - if (values.size() % 2 == 0) { - return (values[middle - 1] + values[middle]) / 2; - } else { - return values[middle]; - } - } - - double calc_standard_deviation(const std::vector<double>& values, double average) const { - double deviations = 0.0; - for (double val : values) { - double diff = val - average; - deviations += (diff * diff); - } - double variance = deviations / values.size(); - return std::sqrt(variance); - } - - template <typename F> - Stats calc_stats(F func) const { + Stats calc_stats(auto func) const { auto values = extract_sorted_values(func); double average = std::accumulate(values.begin(), values.end(), 0.0) / values.size(); double median = calc_median(values); @@ -229,7 +240,7 @@ private: } public: - BenchmarkResults(): _results() {} + BenchmarkCaseResult(): _results() {} void add(const BenchmarkResult& res) { _results.push_back(res); } @@ -244,28 +255,57 @@ public: } }; +std::string +delete_substr_from(const std::string& source, const std::string& substr) +{ + std::string res = source; + auto i = res.find(substr); + while (i != std::string::npos) { + res.erase(i, substr.length()); + i = res.find(substr, i); + } + return res; +} + +vespalib::string +get_class_name(const auto& obj) +{ + auto res = obj.getClassName(); + res = delete_substr_from(res, "search::attribute::"); + res = delete_substr_from(res, "search::queryeval::"); + res = delete_substr_from(res, "vespalib::btree::"); + res = delete_substr_from(res, "search::"); + res = delete_substr_from(res, "vespalib::"); + res = delete_substr_from(res, "anonymous namespace"); + return res; +} + BenchmarkResult -strict_search(SearchIterator& itr, uint32_t docid_limit, double estimate, double strict_cost) +strict_search(Blueprint& blueprint, MatchData& md, uint32_t docid_limit) { + auto itr = blueprint.createSearch(md, true); + assert(itr.get()); BenchmarkTimer timer(budget_sec); uint32_t hits = 0; while (timer.has_budget()) { timer.before(); hits = 0; - itr.initRange(1, docid_limit); - uint32_t docid = itr.seekFirst(1); + itr->initRange(1, docid_limit); + uint32_t docid = itr->seekFirst(1); while (docid < docid_limit) { ++hits; - docid = itr.seekNext(docid + 1); + docid = itr->seekNext(docid + 1); } timer.after(); } - return {timer.min_time() * 1000.0, hits + 1, hits, estimate, strict_cost, itr.getClassName()}; + return {timer.min_time() * 1000.0, hits + 1, hits, blueprint.estimate(), blueprint.strict_cost(), get_class_name(*itr), get_class_name(blueprint)}; } BenchmarkResult -non_strict_search(SearchIterator& itr, uint32_t docid_limit, double estimate, double non_strict_cost) +non_strict_search(Blueprint& blueprint, MatchData& md, uint32_t docid_limit) { + auto itr = blueprint.createSearch(md, false); + assert(itr.get()); BenchmarkTimer timer(budget_sec); uint32_t seeks = 0; uint32_t hits = 0; @@ -273,16 +313,16 @@ non_strict_search(SearchIterator& itr, uint32_t docid_limit, double estimate, do timer.before(); seeks = 0; hits = 0; - itr.initRange(1, docid_limit); - for (uint32_t docid = 1; !itr.isAtEnd(docid); ++docid) { + itr->initRange(1, docid_limit); + for (uint32_t docid = 1; !itr->isAtEnd(docid); ++docid) { ++seeks; - if (itr.seek(docid)) { + if (itr->seek(docid)) { ++hits; } } timer.after(); } - return {timer.min_time() * 1000.0, seeks, hits, estimate, non_strict_cost, itr.getClassName()}; + return {timer.min_time() * 1000.0, seeks, hits, blueprint.estimate(), blueprint.cost(), get_class_name(*itr), get_class_name(blueprint)}; } BenchmarkResult @@ -294,13 +334,9 @@ benchmark_search(Blueprint::UP blueprint, uint32_t docid_limit, bool strict) // This is OK as long as we don't do unpacking and only use 1 thread. auto md = MatchData::makeTestInstance(1, 1); if (strict) { - auto iterator = blueprint->createSearch(*md, true); - assert(iterator.get()); - return strict_search(*iterator, docid_limit, blueprint->estimate(), blueprint->strict_cost()); + return strict_search(*blueprint, *md, docid_limit); } else { - auto iterator = blueprint->createSearch(*md, false); - assert(iterator.get()); - return non_strict_search(*iterator, docid_limit, blueprint->estimate(), blueprint->cost()); + return non_strict_search(*blueprint, *md, docid_limit); } } @@ -342,12 +378,18 @@ to_string(QueryOperator query_op) vespalib::string to_string(const Config& attr_config) { + std::ostringstream oss; auto col_type = attr_config.collectionType(); auto basic_type = attr_config.basicType(); if (col_type == CollectionType::SINGLE) { - return basic_type.asString(); + oss << basic_type.asString(); + } else { + oss << col_type.asString() << "<" << basic_type.asString() << ">"; + } + if (attr_config.fastSearch()) { + oss << "(fs)"; } - return vespalib::string(col_type.asString()) + "<" + vespalib::string(basic_type.asString()) + ">"; + return oss.str(); } std::unique_ptr<Node> @@ -408,124 +450,167 @@ run_benchmark(IAttributeContext& attr_ctx, QueryOperator query_op, const benchma } void +print_result_header() +{ + std::cout << "| children | t_ratio | a_ratio | est | hits | seeks | time_ms | cost | ns_per_seek | ms_per_cost | iterator | blueprint |" << std::endl; +} + +void print_result(const BenchmarkResult& res, const benchmark::TermVector& terms, double hit_ratio, uint32_t num_docs) { std::cout << std::fixed << std::setprecision(3) - << "children=" << std::setw(4) << terms.size() - << ", t_ratio=" << std::setw(5) << hit_ratio - << ", a_ratio=" << std::setw(5) << ((double) res.hits / (double) num_docs) - << ", est=" << std::setw(5) << res.estimate - << ", hits=" << std::setw(7) << res.hits - << ", seeks=" << std::setw(8) << res.seeks + << "| " << std::setw(8) << terms.size() + << " | " << std::setw(7) << hit_ratio + << " | " << std::setw(7) << ((double) res.hits / (double) num_docs) + << " | " << std::setw(5) << res.estimate + << " | " << std::setw(8) << res.hits + << " | " << std::setw(8) << res.seeks << std::setprecision(2) - << ", time_ms=" << std::setw(8) << res.time_ms + << " | " << std::setw(8) << res.time_ms << std::setprecision(3) - << ", cost=" << std::setw(8) << res.cost + << " | " << std::setw(8) << res.cost << std::setprecision(2) - << ", ns_per_seek=" << std::setw(8) << res.ns_per_seek() - << ", ms_per_cost=" << std::setw(7) << res.ms_per_cost() - << ", itr=" << res.iterator_name << std::endl; + << " | " << std::setw(11) << res.ns_per_seek() + << " | " << std::setw(11) << res.ms_per_cost() + << " | " << res.iterator_name + << " | " << res.blueprint_name << " |" << std::endl; } void -print_results(const BenchmarkResults& results) +print_result(const BenchmarkCaseResult& result) { std::cout << std::fixed << std::setprecision(3) - << "statistics summary: time_ms=" << results.time_ms_stats().to_string() - << ", ns_per_seek=" << results.ns_per_seek_stats().to_string() - << ", ms_per_cost=" << results.ms_per_cost_stats().to_string() << std::endl << std::endl; + << "summary: time_ms=" << result.time_ms_stats().to_string() + << ", ns_per_seek=" << result.ns_per_seek_stats().to_string() + << ", ms_per_cost=" << result.ms_per_cost_stats().to_string() << std::endl << std::endl; } struct BenchmarkCase { Config attr_cfg; QueryOperator query_op; bool strict; - BenchmarkResults results; - double scaled_cost; - BenchmarkCase(const Config& attr_cfg_in, QueryOperator query_op_in, bool strict_in, const BenchmarkResults& results_in) + BenchmarkCase(const Config& attr_cfg_in, QueryOperator query_op_in, bool strict_in) : attr_cfg(attr_cfg_in), query_op(query_op_in), - strict(strict_in), - results(results_in), + strict(strict_in) + {} + vespalib::string to_string() const { + return "op=" + ::to_string(query_op) + ", cfg=" + ::to_string(attr_cfg) + ", strict=" + (strict ? "true" : "false"); + } +}; + +struct BenchmarkCaseSummary { + BenchmarkCase bcase; + BenchmarkCaseResult result; + double scaled_cost; + BenchmarkCaseSummary(const BenchmarkCase& bcase_in, const BenchmarkCaseResult& result_in) + : bcase(bcase_in), + result(result_in), scaled_cost(1.0) {} - BenchmarkCase(const BenchmarkCase&); - BenchmarkCase& operator=(const BenchmarkCase&); - ~BenchmarkCase(); + BenchmarkCaseSummary(const BenchmarkCaseSummary&); + BenchmarkCaseSummary& operator=(const BenchmarkCaseSummary&); + ~BenchmarkCaseSummary(); }; -BenchmarkCase::BenchmarkCase(const BenchmarkCase&) = default; -BenchmarkCase& BenchmarkCase::operator=(const BenchmarkCase&) = default; -BenchmarkCase::~BenchmarkCase() = default; +BenchmarkCaseSummary::BenchmarkCaseSummary(const BenchmarkCaseSummary&) = default; +BenchmarkCaseSummary& BenchmarkCaseSummary::operator=(const BenchmarkCaseSummary&) = default; +BenchmarkCaseSummary::~BenchmarkCaseSummary() = default; class BenchmarkSummary { private: - std::vector<BenchmarkCase> _cases; - double _baseline_ms_per_cost; + std::vector<BenchmarkCaseSummary> _cases; public: - BenchmarkSummary(double baseline_ms_per_cost_in) - : _cases(), - _baseline_ms_per_cost(baseline_ms_per_cost_in) + BenchmarkSummary() + : _cases() {} - double baseline_ms_per_cost() const { return _baseline_ms_per_cost; } - void add(const Config& attr_cfg, QueryOperator query_op, bool strict, const BenchmarkResults& results) { - _cases.emplace_back(attr_cfg, query_op, strict, results); + void add(const BenchmarkCase& bcase, const BenchmarkCaseResult& result) { + _cases.emplace_back(bcase, result); } void calc_scaled_costs() { std::sort(_cases.begin(), _cases.end(), [](const auto& lhs, const auto& rhs) { - return lhs.results.ms_per_cost_stats().average < rhs.results.ms_per_cost_stats().average; + return lhs.result.ms_per_cost_stats().average < rhs.result.ms_per_cost_stats().average; }); - for (auto& c : _cases) { - c.scaled_cost = c.results.ms_per_cost_stats().average / _baseline_ms_per_cost; + double baseline_ms_per_cost = _cases[0].result.ms_per_cost_stats().average; + for (size_t i = 1; i < _cases.size(); ++i) { + auto& c = _cases[i]; + c.scaled_cost = c.result.ms_per_cost_stats().average / baseline_ms_per_cost; } } - const std::vector<BenchmarkCase>& cases() const { return _cases; } + const std::vector<BenchmarkCaseSummary>& cases() const { return _cases; } }; -vespalib::string -to_string(QueryOperator query_op, const Config& attr_cfg, bool strict) -{ - return "op=" + to_string(query_op) + ", cfg=" + to_string(attr_cfg) + ", strict=" + (strict ? "true" : "false"); -} - void print_summary(const BenchmarkSummary& summary) { - std::cout << "-------- benchmark summary (baseline_ms_per_cost=" << summary.baseline_ms_per_cost() << ") --------" << std::endl; + std::cout << "-------- benchmark summary --------" << std::endl; for (const auto& c : summary.cases()) { std::cout << std::fixed << std::setprecision(3) << "" - << std::setw(40) << std::left << to_string(c.query_op, c.attr_cfg, c.strict) << ": " - << "ms_per_cost=" << std::setw(7) << std::right << c.results.ms_per_cost_stats().to_string() + << std::setw(50) << std::left << c.bcase.to_string() << ": " + << "ms_per_cost=" << std::setw(7) << std::right << c.result.ms_per_cost_stats().to_string() << ", scaled_cost=" << std::setw(7) << c.scaled_cost << std::endl; } } -struct BenchmarkSetup { +struct BenchmarkCaseSetup { uint32_t num_docs; - Config attr_cfg; - QueryOperator query_op; + BenchmarkCase bcase; std::vector<double> hit_ratios; std::vector<uint32_t> child_counts; + uint32_t default_values_per_document; + BenchmarkCaseSetup(uint32_t num_docs_in, + const BenchmarkCase& bcase_in, + const std::vector<double>& hit_ratios_in, + const std::vector<uint32_t>& child_counts_in) + : num_docs(num_docs_in), + bcase(bcase_in), + hit_ratios(hit_ratios_in), + child_counts(child_counts_in), + default_values_per_document(0) + {} + ~BenchmarkCaseSetup() {} +}; + +struct BenchmarkSetup { + uint32_t num_docs; + std::vector<Config> attr_cfgs; + std::vector<QueryOperator> query_ops; std::vector<bool> strictness; + std::vector<double> hit_ratios; + std::vector<uint32_t> child_counts; uint32_t default_values_per_document; BenchmarkSetup(uint32_t num_docs_in, - Config attr_cfg_in, - QueryOperator query_op_in, + const std::vector<Config>& attr_cfgs_in, + const std::vector<QueryOperator>& query_ops_in, + const std::vector<bool>& strictness_in, const std::vector<double>& hit_ratios_in, - const std::vector<uint32_t>& child_counts_in, - const std::vector<bool>& strictness_in) + const std::vector<uint32_t>& child_counts_in) : num_docs(num_docs_in), - attr_cfg(attr_cfg_in), - query_op(query_op_in), + attr_cfgs(attr_cfgs_in), + query_ops(query_ops_in), + strictness(strictness_in), hit_ratios(hit_ratios_in), child_counts(child_counts_in), - strictness(strictness_in), default_values_per_document(0) {} - ~BenchmarkSetup() {} + BenchmarkSetup(uint32_t num_docs_in, + const std::vector<Config>& attr_cfgs_in, + const std::vector<QueryOperator>& query_ops_in, + const std::vector<bool>& strictness_in, + const std::vector<double>& hit_ratios_in) + : BenchmarkSetup(num_docs_in, attr_cfgs_in, query_ops_in, strictness_in, hit_ratios_in, {1}) + {} + BenchmarkCaseSetup make_case_setup(const BenchmarkCase& bcase) const { + BenchmarkCaseSetup res(num_docs, bcase, hit_ratios, child_counts); + res.default_values_per_document = default_values_per_document; + return res; + } + ~BenchmarkSetup(); }; +BenchmarkSetup::~BenchmarkSetup() = default; + uint32_t calc_hits_per_term(uint32_t num_docs, double target_hit_ratio, uint32_t children, QueryOperator query_op) { @@ -538,27 +623,44 @@ calc_hits_per_term(uint32_t num_docs, double target_hit_ratio, uint32_t children } } -BenchmarkResults +BenchmarkCaseResult +run_benchmark_case(const BenchmarkCaseSetup& setup) +{ + BenchmarkCaseResult result; + std::cout << "-------- run_benchmark_case: " << setup.bcase.to_string() << " --------" << std::endl; + print_result_header(); + for (double hit_ratio : setup.hit_ratios) { + for (uint32_t children : setup.child_counts) { + uint32_t hits_per_term = calc_hits_per_term(setup.num_docs, hit_ratio, children, setup.bcase.query_op); + HitSpecs hit_specs(55555); + hit_specs.add(setup.default_values_per_document, setup.num_docs); + auto terms = hit_specs.add(children, hits_per_term); + auto attr_ctx = make_attribute_context(setup.bcase.attr_cfg, setup.num_docs, hit_specs); + auto res = run_benchmark(*attr_ctx, setup.bcase.query_op, terms, setup.num_docs + 1, setup.bcase.strict); + print_result(res, terms, hit_ratio, setup.num_docs); + result.add(res); + } + } + print_result(result); + return result; +} + +void run_benchmarks(const BenchmarkSetup& setup) { - BenchmarkResults results; - for (bool strict : setup.strictness) { - std::cout << "-------- run_benchmarks: " << to_string(setup.query_op, setup.attr_cfg, strict) << " --------" << std::endl; - for (double hit_ratio : setup.hit_ratios) { - for (uint32_t children : setup.child_counts) { - uint32_t hits_per_term = calc_hits_per_term(setup.num_docs, hit_ratio, children, setup.query_op); - HitSpecs hit_specs(55555); - hit_specs.add(setup.default_values_per_document, setup.num_docs); - auto terms = hit_specs.add(children, hits_per_term); - auto attr_ctx = make_attribute_context(setup.attr_cfg, setup.num_docs, hit_specs); - auto res = run_benchmark(*attr_ctx, setup.query_op, terms, setup.num_docs + 1, strict); - print_result(res, terms, hit_ratio, setup.num_docs); - results.add(res); + BenchmarkSummary summary; + for (const auto& attr_cfg : setup.attr_cfgs) { + for (auto query_op : setup.query_ops) { + for (bool strict : setup.strictness) { + BenchmarkCase bcase(attr_cfg, query_op, strict); + auto case_setup = setup.make_case_setup(bcase); + auto results = run_benchmark_case(case_setup); + summary.add(bcase, results); } } } - print_results(results); - return results; + summary.calc_scaled_costs(); + print_summary(summary); } Config @@ -570,67 +672,60 @@ make_config(BasicType basic_type, CollectionType col_type, bool fast_search) } constexpr uint32_t num_docs = 10'000'000; -const std::vector<double> hit_ratios = {0.001, 0.01, 0.1, 0.5}; -const std::vector<uint32_t> child_counts = {1, 10, 100, 1000}; +const std::vector<double> base_hit_ratios = {0.001, 0.01, 0.1, 0.5}; const Config int32 = make_config(BasicType::INT32, CollectionType::SINGLE, false); const Config int32_fs = make_config(BasicType::INT32, CollectionType::SINGLE, true); const Config int32_array = make_config(BasicType::INT32, CollectionType::ARRAY, false); const Config int32_array_fs = make_config(BasicType::INT32, CollectionType::ARRAY, true); const Config int32_wset_fs = make_config(BasicType::INT32, CollectionType::WSET, true); const Config str = make_config(BasicType::STRING, CollectionType::SINGLE, false); +const Config str_fs = make_config(BasicType::STRING, CollectionType::SINGLE, true); const Config str_array = make_config(BasicType::STRING, CollectionType::ARRAY, false); +const Config str_array_fs = make_config(BasicType::STRING, CollectionType::ARRAY, true); TEST(IteratorBenchmark, analyze_term_search_in_attributes_without_fast_search) { std::vector<Config> attr_cfgs = {int32, int32_array, str, str_array}; - const std::vector<double> my_hit_ratios = {0.001, 0.005, 0.01, 0.05, 0.1, 0.3, 0.5, 0.7, 0.9}; - BenchmarkSummary summary(25.0); - for (const auto& attr_cfg : attr_cfgs) { - for (bool strict : {true, false}) { - BenchmarkSetup setup(num_docs, attr_cfg, QueryOperator::Term, my_hit_ratios, {1}, {strict}); - setup.default_values_per_document = 1; - auto results = run_benchmarks(setup); - summary.add(attr_cfg, QueryOperator::Term, strict, results); - } - } - summary.calc_scaled_costs(); - print_summary(summary); -} - -TEST(IteratorBenchmark, term_benchmark) -{ - BenchmarkSetup setup(num_docs, int32_fs, QueryOperator::Term, hit_ratios, {1}, {true, false}); + const std::vector<double> hit_ratios = {0.001, 0.005, 0.01, 0.05, 0.1, 0.3, 0.5, 0.7, 0.9}; + BenchmarkSetup setup(num_docs, attr_cfgs, {QueryOperator::Term}, {true, false}, hit_ratios); + setup.default_values_per_document = 1; run_benchmarks(setup); } -TEST(IteratorBenchmark, in_benchmark) +TEST(IteratorBenchmark, analyze_term_search_in_attributes_with_fast_search) { - BenchmarkSetup setup(num_docs, int32_array_fs, QueryOperator::In, hit_ratios, child_counts, {true, false}); + std::vector<Config> attr_cfgs = {int32_array, int32_fs}; //, int32_array_fs, str_fs, str_array_fs}; + const std::vector<double> hit_ratios = {0.001, 0.01, 0.1, 0.2, 0.4, 0.6, 0.8, 1.0}; + BenchmarkSetup setup(num_docs, attr_cfgs, {QueryOperator::Term}, {true, false}, hit_ratios); + setup.default_values_per_document = 1; run_benchmarks(setup); } -TEST(IteratorBenchmark, weighted_set_benchmark) +TEST(IteratorBenchmark, analyze_complex_leaf_operators) { - BenchmarkSetup setup(num_docs, int32_array_fs, QueryOperator::WeightedSet, hit_ratios, child_counts, {true, false}); + std::vector<Config> attr_cfgs = {int32_array_fs}; + std::vector<QueryOperator> query_ops = {QueryOperator::In, QueryOperator::DotProduct}; + const std::vector<double> hit_ratios = {0.001, 0.01, 0.1, 0.2, 0.4, 0.6, 0.8}; + BenchmarkSetup setup(num_docs, attr_cfgs, query_ops, {true, false}, hit_ratios, {1, 2, 10, 100}); run_benchmarks(setup); } -TEST(IteratorBenchmark, dot_product_benchmark) +TEST(IteratorBenchmark, term_benchmark) { - BenchmarkSetup setup(num_docs, int32_wset_fs, QueryOperator::DotProduct, hit_ratios, child_counts, {true, false}); + BenchmarkSetup setup(num_docs, {int32_fs}, {QueryOperator::Term}, {true, false}, base_hit_ratios); run_benchmarks(setup); } TEST(IteratorBenchmark, and_benchmark) { - BenchmarkSetup setup(num_docs, int32_array_fs, QueryOperator::And, hit_ratios, {1, 2, 4, 8}, {true, false}); + BenchmarkSetup setup(num_docs, {int32_array_fs}, {QueryOperator::And}, {true, false}, base_hit_ratios, {1, 2, 4, 8}); run_benchmarks(setup); } TEST(IteratorBenchmark, or_benchmark) { - BenchmarkSetup setup(num_docs, int32_array_fs, QueryOperator::Or, hit_ratios, child_counts, {true, false}); + BenchmarkSetup setup(num_docs, {int32_array_fs}, {QueryOperator::Or}, {true, false}, base_hit_ratios, {1, 10, 100, 1000}); run_benchmarks(setup); } |