Merge pull request #36493 from vespa-engine/boeker/ann-doom-class

Add AnnDoom class specifically for ANN searches

Author: boeker

searchcore/src/tests/proton/matching/CMakeLists.txt

@@ -1,4 +1,12 @@
 # Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+vespa_add_executable(searchcore_ann_deadline_configuration_test_app TEST
+    SOURCES
+    ann_deadline_configuration_test.cpp
+    DEPENDS
+    searchcore_matching
+    GTest::gtest
+)
+vespa_add_test(NAME searchcore_ann_deadline_configuration_test_app COMMAND searchcore_ann_deadline_configuration_test_app)
 vespa_add_executable(searchcore_matching_test_app TEST
     SOURCES
     matching_test.cpp

searchcore/src/tests/proton/matching/ann_deadline_configuration_test.cpp

@@ -0,0 +1,95 @@
+// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include <vespa/searchcore/proton/matching/ann_deadline_configuration.h>
+#include <vespa/vespalib/gtest/gtest.h>
+#include <vespa/vespalib/util/doom.h>
+#include <vespa/vespalib/util/time.h>
+#include <cstdint>
+
+using proton::matching::AnnDeadlineConfiguration;
+using vespalib::Deadline;
+using vespalib::Doom;
+using vespalib::steady_time;
+
+class AnnDeadlineConfigurationTest : public ::testing::Test {
+protected:
+    std::atomic<steady_time> time;
+    Doom doom;
+
+public:
+    AnnDeadlineConfigurationTest();
+    ~AnnDeadlineConfigurationTest() override;
+
+};
+
+AnnDeadlineConfigurationTest::AnnDeadlineConfigurationTest()
+    : time(vespalib::steady_clock::now()),
+      doom(time, time.load() + 1s) {
+}
+
+AnnDeadlineConfigurationTest::~AnnDeadlineConfigurationTest() = default;
+
+TEST_F(AnnDeadlineConfigurationTest, soft_doom_becomes_deadline) {
+    for (auto duration : {50ms, 100ms, 1000ms}) {
+        AnnDeadlineConfiguration config(time.load() + duration);
+
+        for (uint32_t remaining_searches : {1, 2, 3, 5, 10}) {
+            Deadline deadline = config.make_ann_deadline(doom, remaining_searches);
+            EXPECT_EQ(Deadline::Type::BUDGET, deadline.type());
+            EXPECT_EQ(duration, deadline.time_left());
+        }
+    }
+}
+
+TEST_F(AnnDeadlineConfigurationTest, ann_timebudget_becomes_deadline) {
+    for (auto budget : {50ms, 100ms, 1000ms}) {
+        for (auto ann_timeout : {10ms, 20ms, 70ms, 500ms}) { // timeout disabled, acts as soft-timeout
+            AnnDeadlineConfiguration config(budget, false, time.load() + ann_timeout);
+
+            for (uint32_t remaining_searches : {1, 2, 3, 5, 10}) {
+                Deadline deadline = config.make_ann_deadline(doom, remaining_searches);
+                EXPECT_EQ(Deadline::Type::BUDGET, deadline.type());
+                EXPECT_EQ(std::min(budget, ann_timeout), deadline.time_left());
+            }
+        }
+    }
+}
+
+TEST_F(AnnDeadlineConfigurationTest, ann_timeout_becomes_deadline) {
+    for (auto ann_timeout : {10ms, 20ms, 80ms, 500ms}) { // Less than time budget of 2s
+        AnnDeadlineConfiguration config(2s, true, time.load() + ann_timeout);
+
+        for (uint32_t remaining_searches : {1, 2, 5, 10}) {
+            Deadline deadline = config.make_ann_deadline(doom, remaining_searches);
+            EXPECT_EQ(Deadline::Type::TIMEOUT, deadline.type());
+            EXPECT_EQ(ann_timeout / remaining_searches, deadline.time_left());
+        }
+    }
+}
+
+TEST_F(AnnDeadlineConfigurationTest, ann_budget_ann_timeout_interaction_is_handled) {
+    AnnDeadlineConfiguration config(50ms, true, time.load() + 100ms);
+    Deadline deadline = config.make_ann_deadline(doom, 1);
+    EXPECT_EQ(Deadline::Type::BUDGET, deadline.type());
+    EXPECT_EQ(50ms, deadline.time_left());
+
+    Deadline deadline2 = config.make_ann_deadline(doom, 2);
+    EXPECT_EQ(Deadline::Type::TIMEOUT, deadline2.type());
+    EXPECT_EQ(50ms, deadline2.time_left());
+
+    Deadline deadline3 = config.make_ann_deadline(doom, 4);
+    EXPECT_EQ(Deadline::Type::TIMEOUT, deadline3.type());
+    EXPECT_EQ(25ms, deadline3.time_left());
+
+
+    time.store(time.load() + 50ms);
+    Deadline deadline4 = config.make_ann_deadline(doom, 1);
+    EXPECT_EQ(Deadline::Type::TIMEOUT, deadline4.type());
+    EXPECT_EQ(50ms, deadline4.time_left());
+
+    Deadline deadline5 = config.make_ann_deadline(doom, 2);
+    EXPECT_EQ(Deadline::Type::TIMEOUT, deadline5.type());
+    EXPECT_EQ(25ms, deadline5.time_left());
+}
+
+GTEST_MAIN_RUN_ALL_TESTS()

searchcore/src/tests/proton/matching/query_test.cpp

@@ -2,6 +2,7 @@
 // Unit tests for query.
 
 #include <vespa/searchlib/common/serialized_query_tree.h>
+#include <vespa/searchcore/proton/matching/ann_deadline_configuration.h>
 #include <vespa/searchcore/proton/matching/fakesearchcontext.h>
 #include <vespa/searchcore/proton/matching/matchdatareservevisitor.h>
 #include <vespa/searchcore/proton/matching/blueprintbuilder.h>
@@ -1151,26 +1152,28 @@ GlobalFilterBlueprint::~GlobalFilterBlueprint() = default;
 
 TEST(QueryTest, global_filter_is_calculated_and_handled)
 {
+    vespalib::Doom doom(vespalib::Doom::never());
+    proton::matching::AnnDeadlineConfiguration ann_deadline_config(vespalib::steady_time::max());
     // estimated hits = 3, estimated hit ratio = 0.3
     auto result = SimpleResult().addHit(3).addHit(5).addHit(7);
     uint32_t docid_limit = 10;
     { // global filter is not wanted
         GlobalFilterBlueprint bp(result, false);
-        auto res = Query::handle_global_filter(bp, docid_limit, 0, 1, ttb(), nullptr);
+        auto res = Query::handle_global_filter(bp, doom, ann_deadline_config, docid_limit, 0, 1, ttb(), nullptr);
         EXPECT_FALSE(res);
         EXPECT_FALSE(bp.filter);
         EXPECT_EQ(-1.0, bp.estimated_hit_ratio);
     }
     { // estimated_hit_ratio < global_filter_lower_limit
         GlobalFilterBlueprint bp(result, true);
-        auto res = Query::handle_global_filter(bp, docid_limit, 0.31, 1, ttb(), nullptr);
+        auto res = Query::handle_global_filter(bp, doom, ann_deadline_config, docid_limit, 0.31, 1, ttb(), nullptr);
         EXPECT_FALSE(res);
         EXPECT_FALSE(bp.filter);
         EXPECT_EQ(-1.0, bp.estimated_hit_ratio);
     }
     { // estimated_hit_ratio <= global_filter_upper_limit
         GlobalFilterBlueprint bp(result, true);
-        auto res = Query::handle_global_filter(bp, docid_limit, 0, 0.3, ttb(), nullptr);
+        auto res = Query::handle_global_filter(bp, doom, ann_deadline_config, docid_limit, 0, 0.3, ttb(), nullptr);
         EXPECT_TRUE(res);
         EXPECT_TRUE(bp.filter);
         EXPECT_TRUE(bp.filter->is_active());
@@ -1183,7 +1186,7 @@ TEST(QueryTest, global_filter_is_calculated_and_handled)
     }
     { // estimated_hit_ratio > global_filter_upper_limit
         GlobalFilterBlueprint bp(result, true);
-        auto res = Query::handle_global_filter(bp, docid_limit, 0, 0.29, ttb(), nullptr);
+        auto res = Query::handle_global_filter(bp, doom, ann_deadline_config, docid_limit, 0, 0.29, ttb(), nullptr);
         EXPECT_TRUE(res);
         EXPECT_TRUE(bp.filter);
         EXPECT_FALSE(bp.filter->is_active());

searchcore/src/vespa/searchcore/proton/matching/CMakeLists.txt

@@ -1,6 +1,7 @@
 # Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 vespa_add_library(searchcore_matching STATIC
     SOURCES
+    ann_deadline_configuration.cpp
     attribute_limiter.cpp
     blueprintbuilder.cpp
     docid_range_scheduler.cpp

searchcore/src/vespa/searchcore/proton/matching/ann_deadline_configuration.cpp

@@ -0,0 +1,39 @@
+// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include "ann_deadline_configuration.h"
+#include <cassert>
+
+using vespalib::Deadline;
+using vespalib::Doom;
+
+namespace proton::matching {
+
+AnnDeadlineConfiguration::AnnDeadlineConfiguration(vespalib::steady_time soft_doom)
+    : AnnDeadlineConfiguration(vespalib::duration::max(), false, soft_doom) {
+}
+
+AnnDeadlineConfiguration::AnnDeadlineConfiguration(vespalib::duration timebudget, bool timeout_enabled, vespalib::steady_time timeout) noexcept
+    : _timebudget(timebudget),
+      _timeout_enabled(timeout_enabled),
+      _timeout(timeout) {
+}
+
+const vespalib::Deadline AnnDeadlineConfiguration::make_ann_deadline(const vespalib::Doom& doom, uint32_t remaining_searches) const noexcept {
+    assert(remaining_searches > 0);
+    vespalib::steady_time now(doom.getTimeNS());
+    // ANN might hit the deadline due to a depleted time budget or a timeout,
+    // whatever happens first. The timeout might be the ANN-specific timeout
+    // or the soft-timeout. The soft-timeout is used when ANN timeouts
+    // are not enabled, and in this case, reaching the soft-timeout
+    // is not reported as an ANN timeout.
+    vespalib::duration timeout_left = _timeout_enabled ? ((_timeout - now) / remaining_searches)
+                                                       : _timeout - now;
+
+    if (_timebudget < timeout_left) {
+        return doom.make_deadline(now + _timebudget, Deadline::Type::BUDGET);
+    } else {
+        return doom.make_deadline(now + timeout_left, _timeout_enabled ? Deadline::Type::TIMEOUT : Deadline::Type::BUDGET);
+    }
+}
+
+}

searchcore/src/vespa/searchcore/proton/matching/ann_deadline_configuration.h

@@ -0,0 +1,35 @@
+// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#pragma once
+
+#include <vespa/vespalib/util/deadline.h>
+#include <vespa/vespalib/util/doom.h>
+#include <vespa/vespalib/util/time.h>
+
+namespace proton::matching {
+
+/**
+ * Class that stores the ANN time budget and ANN timeout.
+ * Used to create Deadline objects for the individual ANN searches.
+ */
+class AnnDeadlineConfiguration {
+public:
+    AnnDeadlineConfiguration(vespalib::steady_time soft_doom);
+    AnnDeadlineConfiguration(vespalib::duration timebudget, bool timeout_enabled, vespalib::steady_time timeout) noexcept;
+
+    /**
+     * Returns a Deadline for the next ANN search.
+     * This deadline is the minimum of the time budget and the time until the timeout,
+     * where the time until the timeout is distributed equally between all remaining searches if
+     * the timeout is enabled.
+     */
+    const vespalib::Deadline make_ann_deadline(const vespalib::Doom& doom, uint32_t remaining_searches) const noexcept;
+
+private:
+    vespalib::duration    _timebudget;
+    bool                  _timeout_enabled;
+    vespalib::steady_time _timeout;
+};
+
+
+}

searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp

@@ -171,6 +171,7 @@ MatchTools::setup_dump()
 MatchToolsFactory::
 MatchToolsFactory(QueryLimiter               & queryLimiter,
                   const vespalib::Doom       & doom,
+                  const AnnDeadlineConfiguration& ann_deadline_config,
                   ISearchContext             & searchContext,
                   IAttributeContext          & attributeContext,
                   search::engine::Trace      & root_trace,
@@ -231,7 +232,7 @@ MatchToolsFactory(QueryLimiter               & queryLimiter,
         _query.fetchPostings(ExecuteInfo::create(in_flow.rate(), _requestContext.getDoom(), thread_bundle));
         if (is_search) {
             bool use_lazy_filter = LazyFilter::check(_queryEnv.getProperties());
-            _query.handle_global_filter(_requestContext, searchContext.getDocIdLimit(),
+            _query.handle_global_filter(_requestContext, ann_deadline_config, searchContext.getDocIdLimit(),
                                         _create_blueprint_params.global_filter_lower_limit,
                                         _create_blueprint_params.global_filter_upper_limit, trace, sort_by_cost, use_lazy_filter);
         }

searchcore/src/vespa/searchcore/proton/matching/match_tools.h

@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include "ann_deadline_configuration.h"
 #include "field_id_to_name_mapper.h"
 #include "handlerecorder.h"
 #include "isearchcontext.h"
@@ -151,6 +152,7 @@ class MatchToolsFactory
 
     MatchToolsFactory(QueryLimiter & queryLimiter,
                       const vespalib::Doom & softDoom,
+                      const AnnDeadlineConfiguration& ann_deadline_config,
                       ISearchContext &searchContext,
                       IAttributeContext &attributeContext,
                       search::engine::Trace & root_trace,

searchcore/src/vespa/searchcore/proton/matching/matcher.cpp

@@ -1,6 +1,7 @@
 // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "matcher.h"
+#include "ann_deadline_configuration.h"
 #include "isearchcontext.h"
 #include "match_master.h"
 #include "match_context.h"
@@ -165,8 +166,9 @@ Matcher::create_match_tools_factory(const search::engine::Request &request, ISea
                    _stats.softDoomFactor(), factor, hasFactorOverride, vespalib::count_ns(safeLeft));
     }
     vespalib::Doom doom(_now_ref, safeDoom, request.getTimeOfDoom(), hasFactorOverride);
+    AnnDeadlineConfiguration ann_deadline_config(safeDoom);
     const auto& queryTree = request.getSerializedQueryTree();
-    return std::make_unique<MatchToolsFactory>(_queryLimiter, doom, searchContext, attrContext,
+    return std::make_unique<MatchToolsFactory>(_queryLimiter, doom, ann_deadline_config, searchContext, attrContext,
                                                request.trace(), queryTree, request.location,
                                                _viewResolver, metaStore, _indexEnv, *_rankSetup,
                                                rankProperties, feature_overrides, thread_bundle,

searchcore/src/vespa/searchcore/proton/matching/query.cpp

@@ -1,6 +1,7 @@
 // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "query.h"
+#include "ann_deadline_configuration.h"
 #include "blueprintbuilder.h"
 #include "matchdatareservevisitor.h"
 #include "resolveviewvisitor.h"
@@ -273,11 +274,11 @@ Query::fetchPostings(const ExecuteInfo & executeInfo)
 }
 
 void
-Query::handle_global_filter(const IRequestContext & requestContext, uint32_t docid_limit,
+Query::handle_global_filter(const IRequestContext & requestContext, const AnnDeadlineConfiguration& ann_deadline_config, uint32_t docid_limit,
                             double global_filter_lower_limit, double global_filter_upper_limit,
                             search::engine::Trace& trace, bool sort_by_cost, bool use_lazy_filter)
 {
-    if (!handle_global_filter(*_blueprint, docid_limit, global_filter_lower_limit, global_filter_upper_limit,
+    if (!handle_global_filter(*_blueprint, requestContext.getDoom(), ann_deadline_config, docid_limit, global_filter_lower_limit, global_filter_upper_limit,
                               requestContext.thread_bundle(), &trace, use_lazy_filter))
     {
         return;
@@ -292,7 +293,7 @@ Query::handle_global_filter(const IRequestContext & requestContext, uint32_t doc
 }
 
 bool
-Query::handle_global_filter(Blueprint& blueprint, uint32_t docid_limit,
+Query::handle_global_filter(Blueprint& blueprint, const vespalib::Doom& doom, const AnnDeadlineConfiguration& ann_deadline_config, uint32_t docid_limit,
                             double global_filter_lower_limit, double global_filter_upper_limit,
                             vespalib::ThreadBundle &thread_bundle, search::engine::Trace* trace, bool use_lazy_filter)
 {
@@ -359,12 +360,12 @@ Query::handle_global_filter(Blueprint& blueprint, uint32_t docid_limit,
         trace->addEvent(5, "Handle global filter in query execution plan");
     }
     blueprint.set_global_filter(*global_filter, estimated_hit_ratio);
-    perform_ann_searches(blueprint);
+    perform_ann_searches(blueprint, doom, ann_deadline_config);
     return true;
 }
 
 void
-Query::perform_ann_searches(Blueprint& blueprint)
+Query::perform_ann_searches(Blueprint& blueprint, const vespalib::Doom& doom, const AnnDeadlineConfiguration& ann_deadline_config)
 {
     std::queue<search::queryeval::NearestNeighborBlueprint*> ann_blueprints;
     blueprint.each_node_post_order([&ann_blueprints](Blueprint& bp) {
@@ -375,7 +376,8 @@ Query::perform_ann_searches(Blueprint& blueprint)
         }
     });
     while (!ann_blueprints.empty()) {
-        ann_blueprints.front()->perform_index_search();
+        const vespalib::Deadline deadline = ann_deadline_config.make_ann_deadline(doom, ann_blueprints.size());
+        ann_blueprints.front()->perform_index_search(deadline);
         ann_blueprints.pop();
     }
 }