Skip to content

Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences

Timeout `filter_result_iterator` during `compute_iterators`. (#1785)

Harpreet Sangarcf5278f267c0
diff --git a/include/filter_result_iterator.h b/include/filter_result_iterator.h
index abec6254..d35744cc 100644
--- a/include/filter_result_iterator.h
+++ b/include/filter_result_iterator.h
@@ -227,6 +227,12 @@ struct filter_result_t {
struct filter_result_iterator_timeout_info {
filter_result_iterator_timeout_info(uint64_t search_begin_us, uint64_t search_stop_us);
+ filter_result_iterator_timeout_info(const filter_result_iterator_timeout_info& obj) {
+ function_call_counter = obj.function_call_counter;
+ search_begin_us = obj.search_begin_us;
+ search_stop_us = obj.search_stop_us;
+ }
+
uint16_t function_call_counter = 0;
uint64_t search_begin_us = 0;
uint64_t search_stop_us = UINT64_MAX;
@@ -316,7 +322,7 @@ private:
void get_n_ids(const uint32_t& n, filter_result_t*& result, const bool& override_timeout = false);
/// Updates `validity` of the iterator to `timed_out` if condition is met. Assumes `timeout_info` is not null.
- inline bool is_timed_out();
+ inline bool is_timed_out(const bool& override_function_call_counter = false);
/// Advances the iterator until the doc value reaches or just overshoots id. The iterator may become invalid during
/// this operation.
diff --git a/src/filter_result_iterator.cpp b/src/filter_result_iterator.cpp
index e4a94e13..4712024b 100644
--- a/src/filter_result_iterator.cpp
+++ b/src/filter_result_iterator.cpp
@@ -986,7 +986,10 @@ void filter_result_iterator_t::init() {
}
}
+ id_lists.reserve(id_lists.size() + lists.size());
id_lists.emplace_back(std::move(lists));
+
+ id_list_iterators.reserve(id_list_iterators.size() + iters.size());
id_list_iterators.emplace_back(std::move(iters));
}
@@ -1108,7 +1111,10 @@ void filter_result_iterator_t::init() {
}
}
+ id_lists.reserve(id_lists.size() + lists.size());
id_lists.emplace_back(std::move(lists));
+
+ id_list_iterators.reserve(id_list_iterators.size() + iters.size());
id_list_iterators.emplace_back(std::move(iters));
}
@@ -2218,16 +2224,11 @@ void filter_result_iterator_t::get_n_ids(const uint32_t& n, filter_result_t*& re
return;
}
- if (override_timeout) {
- result_index = 0;
- } else if (timeout_info != nullptr) {
+ if (!override_timeout && timeout_info != nullptr) {
// In Index::search_wildcard number of calls to get_n_ids will be min(number of threads, filter match ids).
// Therefore, `timeout_info->function_call_counter` won't reach `function_call_modulo` if only incremented on
// function call.
- if (n > function_call_modulo) {
- timeout_info->function_call_counter = function_call_modulo - 1;
- }
- if (is_timed_out()) {
+ if (n > function_call_modulo && is_timed_out(true)) {
return;
}
}
@@ -2251,9 +2252,7 @@ void filter_result_iterator_t::get_n_ids(const uint32_t& n, filter_result_t*& re
result_reference = std::move(filter_result.coll_to_references[result_index]);
}
- if (!override_timeout) {
- validity = result_index < filter_result.count ? valid : invalid;
- }
+ validity = result_index < filter_result.count ? valid : invalid;
}
void filter_result_iterator_t::get_n_ids(const uint32_t& n,
@@ -2270,16 +2269,11 @@ void filter_result_iterator_t::get_n_ids(const uint32_t& n,
return;
}
- if (override_timeout) {
- result_index = 0;
- } else if (timeout_info != nullptr) {
+ if (!override_timeout && timeout_info != nullptr) {
// In Index::search_wildcard number of calls to get_n_ids will be min(number of threads, filter match ids).
// Therefore, `timeout_info->function_call_counter` won't reach `function_call_modulo` if only incremented on
// function call.
- if (n > function_call_modulo) {
- timeout_info->function_call_counter = function_call_modulo - 1;
- }
- if (is_timed_out()) {
+ if (n > function_call_modulo && is_timed_out(true)) {
return;
}
}
@@ -2314,9 +2308,7 @@ void filter_result_iterator_t::get_n_ids(const uint32_t& n,
result_reference = std::move(filter_result.coll_to_references[match_index]);
}
- if (!override_timeout) {
- validity = result_index < filter_result.count ? valid : invalid;
- }
+ validity = result_index < filter_result.count ? valid : invalid;
}
filter_result_iterator_t::filter_result_iterator_t(uint32_t approx_filter_ids_length) :
@@ -2373,6 +2365,11 @@ void filter_result_iterator_t::compute_iterators() {
}
if (filter_node->isOperator) {
+ if (timeout_info != nullptr) {
+ // Passing timeout_info into subtree so individual nodes can check for timeout.
+ left_it->timeout_info = std::make_unique<filter_result_iterator_timeout_info>(*timeout_info);
+ right_it->timeout_info = std::make_unique<filter_result_iterator_timeout_info>(*timeout_info);
+ }
left_it->compute_iterators();
right_it->compute_iterators();
@@ -2382,18 +2379,22 @@ void filter_result_iterator_t::compute_iterators() {
filter_result_t::or_filter_results(left_it->filter_result, right_it->filter_result, filter_result);
}
+ if (left_it->validity == timed_out || right_it->validity == timed_out ||
+ (timeout_info != nullptr && is_timed_out(true))) {
+ validity = timed_out;
+ }
+
// In a complex filter query a sub-expression might not match any document while the full expression does match
// at least one document. If the full expression doesn't match any document, we return early in the search.
- if (filter_result.count == 0) {
+ if (filter_result.count == 0 && validity != timed_out) {
validity = invalid;
- is_filter_result_initialized = true;
- return;
+ } else if (filter_result.count > 0) {
+ result_index = 0;
+ seq_id = filter_result.docs[result_index];
+ approx_filter_ids_length = filter_result.count;
}
- result_index = 0;;
- seq_id = filter_result.docs[result_index];
is_filter_result_initialized = true;
- approx_filter_ids_length = filter_result.count;
// Deleting subtree since we've already computed the result.
delete left_it;
@@ -2446,10 +2447,16 @@ void filter_result_iterator_t::compute_iterators() {
delete[] filter_ids;
filter_ids = out;
std::vector<uint32_t>().swap(f_id_buff); // clears out memory
+
+ if (timeout_info != nullptr && is_timed_out(true)) {
+ goto compute_done;
+ }
}
}
}
+ compute_done:
+
if (!f_id_buff.empty()) {
gfx::timsort(f_id_buff.begin(), f_id_buff.end());
f_id_buff.erase(std::unique( f_id_buff.begin(), f_id_buff.end() ), f_id_buff.end());
@@ -2475,6 +2482,10 @@ void filter_result_iterator_t::compute_iterators() {
size_t result_size = 0;
num_tree->search(a_filter.comparators[0], bool_int64, &filter_result.docs, result_size);
filter_result.count = result_size;
+
+ if (timeout_info != nullptr) {
+ is_timed_out(true);
+ }
} else if (f.is_string()) {
// Resetting posting_list_iterators.
for (uint32_t i = 0; i < posting_lists.size(); i++) {
@@ -2563,6 +2574,10 @@ void filter_result_iterator_t::compute_iterators() {
delete[] or_ids;
or_ids = out;
std::vector<uint32_t>().swap(f_id_buff); // clears out memory
+
+ if (timeout_info != nullptr && is_timed_out(true)) {
+ break;
+ }
}
}
@@ -2596,13 +2611,19 @@ void filter_result_iterator_t::compute_iterators() {
approx_filter_ids_length = filter_result.count;
}
-bool filter_result_iterator_t::is_timed_out() {
- if (validity == timed_out ||
- (++(timeout_info->function_call_counter) % function_call_modulo == 0 && (std::chrono::duration_cast<std::chrono::microseconds>(
- std::chrono::system_clock::now().time_since_epoch()).count() - timeout_info->search_begin_us) > timeout_info->search_stop_us)) {
- validity = timed_out;
+bool filter_result_iterator_t::is_timed_out(const bool& override_function_call_counter) {
+ if (validity == timed_out) {
return true;
}
+
+ if (override_function_call_counter || ++(timeout_info->function_call_counter) % function_call_modulo == 0) {
+ if ((std::chrono::duration_cast<std::chrono::microseconds>(
+ std::chrono::system_clock::now().time_since_epoch()).count() - timeout_info->search_begin_us) > timeout_info->search_stop_us) {
+ validity = timed_out;
+ return true;
+ }
+ }
+
return false;
}
diff --git a/src/index.cpp b/src/index.cpp
index a9943a01..b645a836 100644
--- a/src/index.cpp
+++ b/src/index.cpp
@@ -5967,6 +5967,9 @@ Option<bool> Index::search_wildcard(filter_node_t const* const& filter_tree_root
filter_result_iterator->compute_iterators();
auto const& approx_filter_ids_length = filter_result_iterator->approx_filter_ids_length;
+ // Timed out during computation of filter_result_iterator. We should still process the partial ids.
+ auto timed_out_before_processing = filter_result_iterator->validity == filter_result_iterator_t::timed_out;
+
uint32_t token_bits = 0;
const bool check_for_circuit_break = (approx_filter_ids_length > 1000000);
@@ -5993,10 +5996,10 @@ Option<bool> Index::search_wildcard(filter_node_t const* const& filter_tree_root
Option<bool>* compute_sort_score_statuses[num_threads];
for(size_t thread_id = 0; thread_id < num_threads &&
- filter_result_iterator->validity == filter_result_iterator_t::valid; thread_id++) {
+ filter_result_iterator->validity != filter_result_iterator_t::invalid; thread_id++) {
auto batch_result = new filter_result_t();
filter_result_iterator->get_n_ids(window_size, excluded_result_index, exclude_token_ids,
- exclude_token_ids_size, batch_result);
+ exclude_token_ids_size, batch_result, timed_out_before_processing);
if (batch_result->count == 0) {
delete batch_result;
break;
@@ -6086,7 +6089,8 @@ Option<bool> Index::search_wildcard(filter_node_t const* const& filter_tree_root
std::unique_lock<std::mutex> lock_process(m_process);
cv_process.wait(lock_process, [&](){ return num_processed == num_queued; });
- search_cutoff = parent_search_cutoff || filter_result_iterator->validity == filter_result_iterator_t::timed_out;
+ search_cutoff = parent_search_cutoff || timed_out_before_processing ||
+ filter_result_iterator->validity == filter_result_iterator_t::timed_out;
for(size_t thread_id = 0; thread_id < num_processed; thread_id++) {
if (compute_sort_score_statuses[thread_id] != nullptr) {
@@ -6114,8 +6118,12 @@ Option<bool> Index::search_wildcard(filter_node_t const* const& filter_tree_root
std::chrono::high_resolution_clock::now() - beginF).count();
LOG(INFO) << "Time for raw scoring: " << timeMillisF;*/
- filter_result_iterator->reset();
- if (filter_result_iterator->validity == filter_result_iterator_t::timed_out) {
+ filter_result_iterator->reset(true);
+
+ if (timed_out_before_processing || filter_result_iterator->validity == filter_result_iterator_t::valid) {
+ all_result_ids_len = filter_result_iterator->to_filter_id_array(all_result_ids);
+ search_cutoff = search_cutoff || filter_result_iterator->validity == filter_result_iterator_t::timed_out;
+ } else if (filter_result_iterator->validity == filter_result_iterator_t::timed_out) {
auto partial_result = new filter_result_t();
std::unique_ptr<filter_result_t> partial_result_guard(partial_result);
@@ -6124,9 +6132,6 @@ Option<bool> Index::search_wildcard(filter_node_t const* const& filter_tree_root
all_result_ids_len = partial_result->count;
all_result_ids = partial_result->docs;
partial_result->docs = nullptr;
- } else if (filter_result_iterator->validity == filter_result_iterator_t::valid) {
- all_result_ids_len = filter_result_iterator->to_filter_id_array(all_result_ids);
- search_cutoff = search_cutoff || filter_result_iterator->validity == filter_result_iterator_t::timed_out;
}
return Option<bool>(true);
diff --git a/test/filter_test.cpp b/test/filter_test.cpp
index e1bdada5..88f7b6cd 100644
--- a/test/filter_test.cpp
+++ b/test/filter_test.cpp
@@ -714,6 +714,7 @@ TEST_F(FilterTest, FilterTreeIteratorTimeout) {
ASSERT_EQ(0, result->count); // Shouldn't return results
delete result;
+ filter_iterator->reset(true);
result = new filter_result_t();
filter_iterator->get_n_ids(count, excluded_result_index, nullptr, 0, result, true);