Control the auto-adjustment of targetHits in ANN using post-filtering.

When searching the HNSW index in a post-filtering case,
targetHits is auto-adjusted in an effort to still expose targetHits hits to first-phase ranking after post-filtering.
The following formula is now used to ensure an upper bound of adjustedTargetHits,
avoiding that the search in the HNSW index takes too long.

adjustedTargetHits = min(targetHits / estimatedHitRatio, targetHits * targetHitsMaxAdjustmentFactor).

The target-hits-max-adjustment-factor can be set in a rank profile and overriden per query.
The value is in the range [1.0,inf], with the default being 20.0.

When setting this to 1.0, auto-adjustment of targetHits is effectively disabled.

3 files changed, 27 insertions, 20 deletions

diff --git a/searchcore/src/tests/proton/matching/matching_test.cpp b/searchcore/src/tests/proton/matching/matching_test.cpp
index b59384f1493..6ef462f80c4 100644
--- a/searchcore/src/tests/proton/matching/matching_test.cpp
+++ b/searchcore/src/tests/proton/matching/matching_test.cpp
@@ -1135,12 +1135,12 @@ TEST("require that docsum matcher can extract matching elements from single attr
     EXPECT_EQUAL(list[1], 3u);
 }
 
-struct GlobalFilterParamsFixture {
+struct AttributeBlueprintParamsFixture {
    BlueprintFactory factory;
    search::fef::test::IndexEnvironment index_env;
    RankSetup rank_setup;
    Properties rank_properties;
-    GlobalFilterParamsFixture(double lower_limit, double upper_limit)
+   AttributeBlueprintParamsFixture(double lower_limit, double upper_limit, double target_hits_max_adjustment_factor)
        : factory(),
          index_env(),
          rank_setup(factory, index_env),
@@ -1148,32 +1148,37 @@ struct GlobalFilterParamsFixture {
    {
        rank_setup.set_global_filter_lower_limit(lower_limit);
        rank_setup.set_global_filter_upper_limit(upper_limit);
+       rank_setup.set_target_hits_max_adjustment_factor(target_hits_max_adjustment_factor);
    }
-   void set_query_properties(vespalib::stringref lower_limit, vespalib::stringref upper_limit) {
+   void set_query_properties(vespalib::stringref lower_limit, vespalib::stringref upper_limit,
+                             vespalib::stringref target_hits_max_adjustment_factor) {
        rank_properties.add(GlobalFilterLowerLimit::NAME, lower_limit);
        rank_properties.add(GlobalFilterUpperLimit::NAME, upper_limit);
+       rank_properties.add(TargetHitsMaxAdjustmentFactor::NAME, target_hits_max_adjustment_factor);
    }
    AttributeBlueprintParams extract(uint32_t active_docids = 9, uint32_t docid_limit = 10) const {
-       return MatchToolsFactory::extract_global_filter_params(rank_setup, rank_properties, active_docids, docid_limit);
+       return MatchToolsFactory::extract_attribute_blueprint_params(rank_setup, rank_properties, active_docids, docid_limit);
    }
 };
 
-TEST_F("global filter params are extracted from rank profile", GlobalFilterParamsFixture(0.2, 0.8))
+TEST_F("attribute blueprint params are extracted from rank profile", AttributeBlueprintParamsFixture(0.2, 0.8, 5.0))
 {
     auto params = f.extract();
     EXPECT_EQUAL(0.2, params.global_filter_lower_limit);
     EXPECT_EQUAL(0.8, params.global_filter_upper_limit);
+    EXPECT_EQUAL(5.0, params.target_hits_max_adjustment_factor);
 }
 
-TEST_F("global filter params are extracted from query", GlobalFilterParamsFixture(0.2, 0.8))
+TEST_F("attribute blueprint params are extracted from query", AttributeBlueprintParamsFixture(0.2, 0.8, 5.0))
 {
-    f.set_query_properties("0.15", "0.75");
+    f.set_query_properties("0.15", "0.75", "3.0");
     auto params = f.extract();
     EXPECT_EQUAL(0.15, params.global_filter_lower_limit);
     EXPECT_EQUAL(0.75, params.global_filter_upper_limit);
+    EXPECT_EQUAL(3.0, params.target_hits_max_adjustment_factor);
 }
 
-TEST_F("global filter params are scaled with active hit ratio", GlobalFilterParamsFixture(0.2, 0.8))
+TEST_F("global filter params are scaled with active hit ratio", AttributeBlueprintParamsFixture(0.2, 0.8, 5.0))
 {
     auto params = f.extract(5, 10);
     EXPECT_EQUAL(0.12, params.global_filter_lower_limit);
diff --git a/searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp b/searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp
index c7cbdc29689..a353d4816f6 100644
--- a/searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp
+++ b/searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp
@@ -176,11 +176,11 @@ MatchToolsFactory(QueryLimiter               & queryLimiter,
                   const search::IDocumentMetaStoreContext::IReadGuard::SP * metaStoreReadGuard,
                   bool                         is_search)
     : _queryLimiter(queryLimiter),
-      _global_filter_params(extract_global_filter_params(rankSetup, rankProperties, metaStore.getNumActiveLids(), searchContext.getDocIdLimit())),
+      _attribute_blueprint_params(extract_attribute_blueprint_params(rankSetup, rankProperties, metaStore.getNumActiveLids(), searchContext.getDocIdLimit())),
       _query(),
       _match_limiter(),
       _queryEnv(indexEnv, attributeContext, rankProperties, searchContext.getIndexes()),
-      _requestContext(doom, attributeContext, _queryEnv, _queryEnv.getObjectStore(), _global_filter_params, metaStoreReadGuard),
+      _requestContext(doom, attributeContext, _queryEnv, _queryEnv.getObjectStore(), _attribute_blueprint_params, metaStoreReadGuard),
       _mdl(),
       _rankSetup(rankSetup),
       _featureOverrides(featureOverrides),
@@ -203,8 +203,8 @@ MatchToolsFactory(QueryLimiter               & queryLimiter,
         _query.fetchPostings();
         if (is_search) {
             _query.handle_global_filter(searchContext.getDocIdLimit(),
-                                        _global_filter_params.global_filter_lower_limit,
-                                        _global_filter_params.global_filter_upper_limit,
+                                        _attribute_blueprint_params.global_filter_lower_limit,
+                                        _attribute_blueprint_params.global_filter_upper_limit,
                                         thread_bundle, trace);
         }
         _query.freeze();
@@ -324,18 +324,20 @@ MatchToolsFactory::get_feature_rename_map() const
 }
 
 AttributeBlueprintParams
-MatchToolsFactory::extract_global_filter_params(const RankSetup& rank_setup, const Properties& rank_properties,
-                                                uint32_t active_docids, uint32_t docid_limit)
+MatchToolsFactory::extract_attribute_blueprint_params(const RankSetup& rank_setup, const Properties& rank_properties,
+                                                      uint32_t active_docids, uint32_t docid_limit)
 {
     double lower_limit = GlobalFilterLowerLimit::lookup(rank_properties, rank_setup.get_global_filter_lower_limit());
     double upper_limit = GlobalFilterUpperLimit::lookup(rank_properties, rank_setup.get_global_filter_upper_limit());
+    double target_hits_max_adjustment_factor = TargetHitsMaxAdjustmentFactor::lookup(rank_properties, rank_setup.get_target_hits_max_adjustment_factor());
 
     // Note that we count the reserved docid 0 as active.
     // This ensures that when searchable-copies=1, the ratio is 1.0.
     double active_hit_ratio = std::min(active_docids + 1, docid_limit) / static_cast<double>(docid_limit);
 
     return {lower_limit * active_hit_ratio,
-            upper_limit * active_hit_ratio};
+            upper_limit * active_hit_ratio,
+            target_hits_max_adjustment_factor};
 }
 
 AttributeOperationTask::AttributeOperationTask(const RequestContext & requestContext,
diff --git a/searchcore/src/vespa/searchcore/proton/matching/match_tools.h b/searchcore/src/vespa/searchcore/proton/matching/match_tools.h
index db30ea8d2b2..681690d4c36 100644
--- a/searchcore/src/vespa/searchcore/proton/matching/match_tools.h
+++ b/searchcore/src/vespa/searchcore/proton/matching/match_tools.h
@@ -121,7 +121,7 @@ private:
     using IIndexEnvironment = search::fef::IIndexEnvironment;
     using IDiversifier = search::queryeval::IDiversifier;
     QueryLimiter                     & _queryLimiter;
-    AttributeBlueprintParams           _global_filter_params;
+    AttributeBlueprintParams           _attribute_blueprint_params;
     Query                              _query;
     MaybeMatchPhaseLimiter::UP         _match_limiter;
     std::unique_ptr<RangeQueryLocator> _rangeLocator;
@@ -177,15 +177,15 @@ public:
     const StringStringMap & get_feature_rename_map() const;
 
     /**
-     * Extracts global filter parameters from the rank-profile and query.
+     * Extracts attribute blueprint parameters from the rank-profile and query.
      *
-     * These parameters are expected to be in the range [0.0, 1.0], which matches the range of the estimated hit ratio of the query.
+     * The global filter parameters are expected to be in the range [0.0, 1.0], which matches the range of the estimated hit ratio of the query.
      * When searchable-copies > 1, we must scale the parameters to match the effective range of the estimated hit ratio.
      * This is done by multiplying with the active hit ratio (active docids / docid limit).
      */
     static AttributeBlueprintParams
-    extract_global_filter_params(const RankSetup& rank_setup, const Properties& rank_properties,
-                                 uint32_t active_docids, uint32_t docid_limit);
+    extract_attribute_blueprint_params(const RankSetup& rank_setup, const Properties& rank_properties,
+                                       uint32_t active_docids, uint32_t docid_limit);
 };
 
 }