Enable query override for

- vespa.matching.termwise_limit
- vespa.matching.numthreadspersearch
- vespa.matching.numsearchpartitions
- vespa.matching.minhitsperthread

8 files changed, 110 insertions, 71 deletions

diff --git a/searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp b/searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp
index fc559930417..db3cf83fd85 100644
--- a/searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp
+++ b/searchcore/src/vespa/searchcore/proton/matching/match_tools.cpp
@@ -12,6 +12,7 @@ using search::attribute::IAttributeContext;
 using search::queryeval::IRequestContext;
 using namespace search::fef;
 using namespace search::fef::indexproperties::matchphase;
+using namespace search::fef::indexproperties::matching;
 using search::IDocumentMetaStore;
 
 namespace proton {
@@ -75,7 +76,8 @@ search::fef::RankProgram::UP
 MatchTools::first_phase_program() const {
     auto program = setup_program(_rankSetup.create_first_phase_program(),
                                  _mdl, _queryEnv, _featureOverrides);
-    program->match_data().set_termwise_limit(_rankSetup.get_termwise_limit());
+    program->match_data().set_termwise_limit(TermwiseLimit::lookup(_queryEnv.getProperties(),
+                                                                   _rankSetup.get_termwise_limit()));
     return program;
 }
 
diff --git a/searchcore/src/vespa/searchcore/proton/matching/matcher.cpp b/searchcore/src/vespa/searchcore/proton/matching/matcher.cpp
index 15641e7d36d..22bfc8428b0 100644
--- a/searchcore/src/vespa/searchcore/proton/matching/matcher.cpp
+++ b/searchcore/src/vespa/searchcore/proton/matching/matcher.cpp
@@ -19,6 +19,7 @@
 LOG_SETUP(".proton.matching.matcher");
 
 using search::fef::Properties;
+using namespace search::fef::indexproperties::matching;
 using namespace search;
 using namespace search::engine;
 using namespace search::grouping;
@@ -178,8 +179,7 @@ Matcher::create_match_tools_factory(const search::engine::Request &request,
     return std::make_unique<MatchToolsFactory>(_queryLimiter, vespalib::Doom(_clock, safeDoom),
                                                vespalib::Doom(_clock, request.getTimeOfDoom()), searchContext,
                                                attrContext, request.getStackRef(), request.location, _viewResolver,
-                                               metaStore, _indexEnv, *_rankSetup,
-                                               request.propertiesMap.rankProperties(), feature_overrides);
+                                               metaStore, _indexEnv, *_rankSetup, rankProperties, feature_overrides);
 }
 
 SearchReply::UP
@@ -196,10 +196,12 @@ Matcher::handleGroupingSession(SessionManager &sessionMgr,
     return reply;
 }
 
-size_t Matcher::computeNumThreadsPerSearch(Blueprint::HitEstimate hits) const {
-    size_t threads = _rankSetup->getNumThreadsPerSearch();
-    if ((threads > 1) && (_rankSetup->getMinHitsPerThread() > 0)) {
-        threads = (hits.empty) ? 1 : std::min(threads, numThreads(hits.estHits, _rankSetup->getMinHitsPerThread()));
+size_t
+Matcher::computeNumThreadsPerSearch(Blueprint::HitEstimate hits, const Properties & rankProperties) const {
+    size_t threads = NumThreadsPerSearch::lookup(rankProperties, _rankSetup->getNumThreadsPerSearch());
+    uint32_t minHitsPerThread = MinHitsPerThread::lookup(rankProperties, _rankSetup->getMinHitsPerThread());
+    if ((threads > 1) && (minHitsPerThread > 0)) {
+        threads = (hits.empty) ? 1 : std::min(threads, numThreads(hits.estHits, minHitsPerThread));
     }
     return threads;
 }
@@ -219,7 +221,8 @@ Matcher::match(const SearchRequest &request,
     SearchReply::UP reply = std::make_unique<SearchReply>();
     { // we want to measure full set-up and tear-down time as part of
       // collateral time
-        GroupingContext groupingContext(_clock, request.getTimeOfDoom(), &request.groupSpec[0], request.groupSpec.size());
+        GroupingContext groupingContext(_clock, request.getTimeOfDoom(),
+                                        &request.groupSpec[0], request.groupSpec.size());
         SessionId sessionId(&request.sessionId[0], request.sessionId.size());
         bool shouldCacheSearchSession = false;
         bool shouldCacheGroupingSession = false;
@@ -239,7 +242,8 @@ Matcher::match(const SearchRequest &request,
             owned_objects.feature_overrides.reset(new Properties(*feature_overrides));
             feature_overrides = owned_objects.feature_overrides.get();
         }
-        MatchToolsFactory::UP mtf = create_match_tools_factory(request, searchContext, attrContext, metaStore, *feature_overrides);
+        MatchToolsFactory::UP mtf = create_match_tools_factory(request, searchContext, attrContext,
+                                                               metaStore, *feature_overrides);
         if (!mtf->valid()) {
             reply->errorCode = ECODE_QUERY_PARSE_ERROR;
             reply->errorMessage = "query execution failed (invalid query)";
@@ -250,33 +254,42 @@ Matcher::match(const SearchRequest &request,
                            _rankSetup->getRankScoreDropLimit(), request.offset, request.maxhits,
                            !_rankSetup->getSecondPhaseRank().empty(), !willNotNeedRanking(request, groupingContext));
 
-        ResultProcessor rp(attrContext, metaStore, sessionMgr, groupingContext, sessionId, request.sortSpec, params.offset, params.hits);
+        ResultProcessor rp(attrContext, metaStore, sessionMgr, groupingContext, sessionId,
+                           request.sortSpec, params.offset, params.hits);
 
-        size_t numThreadsPerSearch = computeNumThreadsPerSearch(mtf->estimate());
+        const Properties & rankProperties = request.propertiesMap.rankProperties();
+        size_t numThreadsPerSearch = computeNumThreadsPerSearch(mtf->estimate(), rankProperties);
         LimitedThreadBundleWrapper limitedThreadBundle(threadBundle, numThreadsPerSearch);
         MatchMaster master;
-        ResultProcessor::Result::UP result = master.match(params, limitedThreadBundle, *mtf, rp, _distributionKey, _rankSetup->getNumSearchPartitions());
+        uint32_t numSearchPartitions = NumSearchPartitions::lookup(rankProperties,
+                                                                   _rankSetup->getNumSearchPartitions());
+        ResultProcessor::Result::UP result = master.match(params, limitedThreadBundle, *mtf, rp,
+                                                          _distributionKey, numSearchPartitions);
         my_stats = MatchMaster::getStats(std::move(master));
-        size_t estimate = std::min(static_cast<size_t>(metaStore.getCommittedDocIdLimit()), mtf->match_limiter().getDocIdSpaceEstimate());
+        size_t estimate = std::min(static_cast<size_t>(metaStore.getCommittedDocIdLimit()),
+                                   mtf->match_limiter().getDocIdSpaceEstimate());
         bool wasLimited = mtf->match_limiter().was_limited();
         if (shouldCacheSearchSession && ((result->_numFs4Hits != 0) || shouldCacheGroupingSession)) {
-            SearchSession::SP session = std::make_shared<SearchSession>(sessionId, request.getTimeOfDoom(), std::move(mtf), std::move(owned_objects));
+            SearchSession::SP session = std::make_shared<SearchSession>(sessionId, request.getTimeOfDoom(),
+                                                                        std::move(mtf), std::move(owned_objects));
             session->releaseEnumGuards();
             sessionMgr.insert(std::move(session));
         }
         reply = std::move(result->_reply);
+        SearchReply::Coverage & coverage = reply->coverage;
         if (wasLimited) {
-            reply->coverage.degradeMatchPhase();
+            coverage.degradeMatchPhase();
         }
         if (my_stats.softDoomed()) {
-            reply->coverage.degradeTimeout();
+            coverage.degradeTimeout();
         }
-        reply->coverage.setActive(metaStore.getNumActiveLids());
-        reply->coverage.setSoonActive(metaStore.getNumActiveLids()); //TODO this should be calculated with ClusterState calculator.
-        reply->coverage.setCovered(std::min(static_cast<size_t>(metaStore.getNumActiveLids()),
-                                            (estimate * metaStore.getNumActiveLids())/metaStore.getCommittedDocIdLimit()));
+        coverage.setActive(metaStore.getNumActiveLids());
+        //TODO this should be calculated with ClusterState calculator.
+        coverage.setSoonActive(metaStore.getNumActiveLids());
+        coverage.setCovered(std::min(static_cast<size_t>(metaStore.getNumActiveLids()),
+                                     (estimate * metaStore.getNumActiveLids())/metaStore.getCommittedDocIdLimit()));
         LOG(debug, "numThreadsPerSearch = %d. Configured = %d, estimated hits=%d, totalHits=%ld",
-                   numThreadsPerSearch, _rankSetup->getNumThreadsPerSearch(), mtf->estimate().estHits, reply->totalHitCount);
+            numThreadsPerSearch, _rankSetup->getNumThreadsPerSearch(), mtf->estimate().estHits, reply->totalHitCount);
     }
     total_matching_time.stop();
     my_stats.queryCollateralTime(total_matching_time.elapsed().sec() - my_stats.queryLatencyAvg());
diff --git a/searchcore/src/vespa/searchcore/proton/matching/matcher.h b/searchcore/src/vespa/searchcore/proton/matching/matcher.h
index d8128f90f9b..88c1116253b 100644
--- a/searchcore/src/vespa/searchcore/proton/matching/matcher.h
+++ b/searchcore/src/vespa/searchcore/proton/matching/matcher.h
@@ -71,7 +71,8 @@ private:
             search::grouping::GroupingContext & groupingContext,
             std::unique_ptr<search::grouping::GroupingSession> gs);
 
-    size_t computeNumThreadsPerSearch(search::queryeval::Blueprint::HitEstimate hits) const;
+    size_t computeNumThreadsPerSearch(search::queryeval::Blueprint::HitEstimate hits,
+                                      const search::fef::Properties & rankProperties) const;
 public:
     /**
      * Convenience typedefs.
diff --git a/searchcore/src/vespa/searchcore/proton/matching/queryenvironment.h b/searchcore/src/vespa/searchcore/proton/matching/queryenvironment.h
index 490379de7ae..25de6663384 100644
--- a/searchcore/src/vespa/searchcore/proton/matching/queryenvironment.h
+++ b/searchcore/src/vespa/searchcore/proton/matching/queryenvironment.h
@@ -58,24 +58,24 @@ public:
     }
 
     // inherited from search::fef::IQueryEnvironment
-    virtual const search::fef::Properties &getProperties() const;
+    const search::fef::Properties &getProperties() const override;
 
     // inherited from search::fef::IQueryEnvironment
-    virtual uint32_t getNumTerms() const;
+    uint32_t getNumTerms() const override;
 
     // inherited from search::fef::IQueryEnvironment
-    virtual const search::fef::ITermData *getTerm(uint32_t idx) const;
+    const search::fef::ITermData *getTerm(uint32_t idx) const override;
 
     // inherited from search::fef::IQueryEnvironment
-    virtual const search::fef::Location & getLocation() const;
+    const search::fef::Location & getLocation() const override;
 
     // inherited from search::fef::IQueryEnvironment
-    virtual const search::attribute::IAttributeContext & getAttributeContext() const;
+    const search::attribute::IAttributeContext & getAttributeContext() const override;
 
     // inherited from search::fef::IQueryEnvironment
-    virtual const search::fef::IIndexEnvironment & getIndexEnvironment() const;
+    const search::fef::IIndexEnvironment & getIndexEnvironment() const override;
 
-    virtual ~QueryEnvironment();
+    ~QueryEnvironment();
 };
 
 } // namespace matching
diff --git a/searchcore/src/vespa/searchcore/proton/server/matchview.cpp b/searchcore/src/vespa/searchcore/proton/server/matchview.cpp
index 466db2a7233..e1dec2482a4 100644
--- a/searchcore/src/vespa/searchcore/proton/server/matchview.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/matchview.cpp
@@ -1,15 +1,11 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/fastos/fastos.h>
 #include "matchview.h"
 #include "searchcontext.h"
-#include <vespa/searchcommon/attribute/iattributecontext.h>
 #include <vespa/searchcore/proton/common/indexsearchabletosearchableadapter.h>
-#include <vespa/searchcore/proton/matching/search_session.h>
-#include <vespa/searchlib/queryeval/field_spec.h>
-#include <vespa/searchlib/queryeval/searchable.h>
 #include <vespa/searchlib/engine/searchrequest.h>
 #include <vespa/searchlib/engine/searchreply.h>
+
 #include <vespa/log/log.h>
 LOG_SETUP(".proton.server.matchview");
 
diff --git a/searchlib/src/vespa/searchlib/fef/indexproperties.cpp b/searchlib/src/vespa/searchlib/fef/indexproperties.cpp
index ca7cf05de37..23874924ddb 100644
--- a/searchlib/src/vespa/searchlib/fef/indexproperties.cpp
+++ b/searchlib/src/vespa/searchlib/fef/indexproperties.cpp
@@ -1,9 +1,7 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/fastos/fastos.h>
 #include "indexproperties.h"
 #include "properties.h"
-#include <limits>
 
 namespace search {
 namespace fef {
@@ -141,7 +139,13 @@ const double TermwiseLimit::DEFAULT_VALUE(1.0);
 double
 TermwiseLimit::lookup(const Properties &props)
 {
-    return lookupDouble(props, NAME, DEFAULT_VALUE);
+    return lookup(props, DEFAULT_VALUE);
+}
+
+double
+TermwiseLimit::lookup(const Properties &props, double defaultValue)
+{
+    return lookupDouble(props, NAME, defaultValue);
 }
 
 const vespalib::string NumThreadsPerSearch::NAME("vespa.matching.numthreadspersearch");
@@ -150,7 +154,13 @@ const uint32_t NumThreadsPerSearch::DEFAULT_VALUE(std::numeric_limits<uint32_t>:
 uint32_t
 NumThreadsPerSearch::lookup(const Properties &props)
 {
-    return lookupUint32(props, NAME, DEFAULT_VALUE);
+    return lookup(props, DEFAULT_VALUE);
+}
+
+uint32_t
+NumThreadsPerSearch::lookup(const Properties &props, uint32_t defaultValue)
+{
+    return lookupUint32(props, NAME, defaultValue);
 }
 
 const vespalib::string NumSearchPartitions::NAME("vespa.matching.numsearchpartitions");
@@ -159,7 +169,13 @@ const uint32_t NumSearchPartitions::DEFAULT_VALUE(1);
 uint32_t
 NumSearchPartitions::lookup(const Properties &props)
 {
-    return lookupUint32(props, NAME, DEFAULT_VALUE);
+    return lookup(props, DEFAULT_VALUE);
+}
+
+uint32_t
+NumSearchPartitions::lookup(const Properties &props, uint32_t defaultValue)
+{
+    return lookupUint32(props, NAME, defaultValue);
 }
 
 const vespalib::string MinHitsPerThread::NAME("vespa.matching.minhitsperthread");
@@ -168,7 +184,13 @@ const uint32_t MinHitsPerThread::DEFAULT_VALUE(0);
 uint32_t
 MinHitsPerThread::lookup(const Properties &props)
 {
-    return lookupUint32(props, NAME, DEFAULT_VALUE);
+    return lookup(props, DEFAULT_VALUE);
+}
+
+uint32_t
+MinHitsPerThread::lookup(const Properties &props, uint32_t defaultValue)
+{
+    return lookupUint32(props, NAME, defaultValue);
 }
 
 } // namespace matching
diff --git a/searchlib/src/vespa/searchlib/fef/indexproperties.h b/searchlib/src/vespa/searchlib/fef/indexproperties.h
index 7a1818a1cd4..2a37f2f93fd 100644
--- a/searchlib/src/vespa/searchlib/fef/indexproperties.h
+++ b/searchlib/src/vespa/searchlib/fef/indexproperties.h
@@ -92,6 +92,7 @@ namespace matching {
         static const vespalib::string NAME;
         static const double DEFAULT_VALUE;
         static double lookup(const Properties &props);
+        static double lookup(const Properties &props, double defaultValue);
     };
 
     /**
@@ -101,6 +102,7 @@ namespace matching {
         static const vespalib::string NAME;
         static const uint32_t DEFAULT_VALUE;
         static uint32_t lookup(const Properties &props);
+        static uint32_t lookup(const Properties &props, uint32_t defaultValue);
     };
     /**
      * Property for the minimum number of hits per thread.
@@ -109,6 +111,7 @@ namespace matching {
         static const vespalib::string NAME;
         static const uint32_t DEFAULT_VALUE;
         static uint32_t lookup(const Properties &props);
+        static uint32_t lookup(const Properties &props, uint32_t defaultValue);
     };
     /**
      * Property for the number of partitions inside the docid space.
@@ -118,6 +121,7 @@ namespace matching {
         static const vespalib::string NAME;
         static const uint32_t DEFAULT_VALUE;
         static uint32_t lookup(const Properties &props);
+        static uint32_t lookup(const Properties &props, uint32_t defaultValue);
     };
 }
 
diff --git a/searchlib/src/vespa/searchlib/fef/ranksetup.cpp b/searchlib/src/vespa/searchlib/fef/ranksetup.cpp
index 45c3bafd640..d3262a7d2d8 100644
--- a/searchlib/src/vespa/searchlib/fef/ranksetup.cpp
+++ b/searchlib/src/vespa/searchlib/fef/ranksetup.cpp
@@ -1,13 +1,12 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/fastos/fastos.h>
-#include <vespa/log/log.h>
-LOG_SETUP(".fef.ranksetup");
 #include "ranksetup.h"
-#include "idumpfeaturevisitor.h"
 #include "indexproperties.h"
 #include "featurenameparser.h"
 
+#include <vespa/log/log.h>
+LOG_SETUP(".fef.ranksetup");
+
 namespace {
 class VisitorAdapter : public search::fef::IDumpFeatureVisitor
 {
@@ -23,6 +22,8 @@ public:
 
 namespace search {
 namespace fef {
+    
+using namespace indexproperties;    
 
 RankSetup::RankSetup(const BlueprintFactory &factory, const IIndexEnvironment &indexEnv)
     : _factory(factory),
@@ -65,39 +66,39 @@ RankSetup::~RankSetup() { }
 void
 RankSetup::configure()
 {
-    setFirstPhaseRank(indexproperties::rank::FirstPhase::lookup(_indexEnv.getProperties()));
-    setSecondPhaseRank(indexproperties::rank::SecondPhase::lookup(_indexEnv.getProperties()));
-    std::vector<vespalib::string> summaryFeatures = indexproperties::summary::Feature::lookup(_indexEnv.getProperties());
+    setFirstPhaseRank(rank::FirstPhase::lookup(_indexEnv.getProperties()));
+    setSecondPhaseRank(rank::SecondPhase::lookup(_indexEnv.getProperties()));
+    std::vector<vespalib::string> summaryFeatures = summary::Feature::lookup(_indexEnv.getProperties());
     for (uint32_t i = 0; i < summaryFeatures.size(); ++i) {
         addSummaryFeature(summaryFeatures[i]);
     }
-    setIgnoreDefaultRankFeatures(indexproperties::dump::IgnoreDefaultFeatures::check(_indexEnv.getProperties()));
-    std::vector<vespalib::string> dumpFeatures = indexproperties::dump::Feature::lookup(_indexEnv.getProperties());
+    setIgnoreDefaultRankFeatures(dump::IgnoreDefaultFeatures::check(_indexEnv.getProperties()));
+    std::vector<vespalib::string> dumpFeatures = dump::Feature::lookup(_indexEnv.getProperties());
     for (uint32_t i = 0; i < dumpFeatures.size(); ++i) {
         addDumpFeature(dumpFeatures[i]);
     }
-    set_termwise_limit(indexproperties::matching::TermwiseLimit::lookup(_indexEnv.getProperties()));
-    setNumThreadsPerSearch(indexproperties::matching::NumThreadsPerSearch::lookup(_indexEnv.getProperties()));
-    setMinHitsPerThread(indexproperties::matching::MinHitsPerThread::lookup(_indexEnv.getProperties()));
-    setNumSearchPartitions(indexproperties::matching::NumSearchPartitions::lookup(_indexEnv.getProperties()));
-    setHeapSize(indexproperties::hitcollector::HeapSize::lookup(_indexEnv.getProperties()));
-    setArraySize(indexproperties::hitcollector::ArraySize::lookup(_indexEnv.getProperties()));
-    setDegradationAttribute(indexproperties::matchphase::DegradationAttribute::lookup(_indexEnv.getProperties()));
-    setDegradationOrderAscending(indexproperties::matchphase::DegradationAscendingOrder::lookup(_indexEnv.getProperties()));
-    setDegradationMaxHits(indexproperties::matchphase::DegradationMaxHits::lookup(_indexEnv.getProperties()));
-    setDegradationMaxFilterCoverage(indexproperties::matchphase::DegradationMaxFilterCoverage::lookup(_indexEnv.getProperties()));
-    setDegradationSamplePercentage(indexproperties::matchphase::DegradationSamplePercentage::lookup(_indexEnv.getProperties()));
-    setDegradationPostFilterMultiplier(indexproperties::matchphase::DegradationPostFilterMultiplier::lookup(_indexEnv.getProperties()));
-    setDiversityAttribute(indexproperties::matchphase::DiversityAttribute::lookup(_indexEnv.getProperties()));
-    setDiversityMinGroups(indexproperties::matchphase::DiversityMinGroups::lookup(_indexEnv.getProperties()));
-    setDiversityCutoffFactor(indexproperties::matchphase::DiversityCutoffFactor::lookup(_indexEnv.getProperties()));
-    setDiversityCutoffStrategy(indexproperties::matchphase::DiversityCutoffStrategy::lookup(_indexEnv.getProperties()));
-    setEstimatePoint(indexproperties::hitcollector::EstimatePoint::lookup(_indexEnv.getProperties()));
-    setEstimateLimit(indexproperties::hitcollector::EstimateLimit::lookup(_indexEnv.getProperties()));
-    setRankScoreDropLimit(indexproperties::hitcollector::RankScoreDropLimit::lookup(_indexEnv.getProperties()));
-    setSoftTimeoutEnabled(indexproperties::softtimeout::Enabled::lookup(_indexEnv.getProperties()));
-    setSoftTimeoutTailCost(indexproperties::softtimeout::TailCost::lookup(_indexEnv.getProperties()));
-    setSoftTimeoutFactor(indexproperties::softtimeout::Factor::lookup(_indexEnv.getProperties()));
+    set_termwise_limit(matching::TermwiseLimit::lookup(_indexEnv.getProperties()));
+    setNumThreadsPerSearch(matching::NumThreadsPerSearch::lookup(_indexEnv.getProperties()));
+    setMinHitsPerThread(matching::MinHitsPerThread::lookup(_indexEnv.getProperties()));
+    setNumSearchPartitions(matching::NumSearchPartitions::lookup(_indexEnv.getProperties()));
+    setHeapSize(hitcollector::HeapSize::lookup(_indexEnv.getProperties()));
+    setArraySize(hitcollector::ArraySize::lookup(_indexEnv.getProperties()));
+    setDegradationAttribute(matchphase::DegradationAttribute::lookup(_indexEnv.getProperties()));
+    setDegradationOrderAscending(matchphase::DegradationAscendingOrder::lookup(_indexEnv.getProperties()));
+    setDegradationMaxHits(matchphase::DegradationMaxHits::lookup(_indexEnv.getProperties()));
+    setDegradationMaxFilterCoverage(matchphase::DegradationMaxFilterCoverage::lookup(_indexEnv.getProperties()));
+    setDegradationSamplePercentage(matchphase::DegradationSamplePercentage::lookup(_indexEnv.getProperties()));
+    setDegradationPostFilterMultiplier(matchphase::DegradationPostFilterMultiplier::lookup(_indexEnv.getProperties()));
+    setDiversityAttribute(matchphase::DiversityAttribute::lookup(_indexEnv.getProperties()));
+    setDiversityMinGroups(matchphase::DiversityMinGroups::lookup(_indexEnv.getProperties()));
+    setDiversityCutoffFactor(matchphase::DiversityCutoffFactor::lookup(_indexEnv.getProperties()));
+    setDiversityCutoffStrategy(matchphase::DiversityCutoffStrategy::lookup(_indexEnv.getProperties()));
+    setEstimatePoint(hitcollector::EstimatePoint::lookup(_indexEnv.getProperties()));
+    setEstimateLimit(hitcollector::EstimateLimit::lookup(_indexEnv.getProperties()));
+    setRankScoreDropLimit(hitcollector::RankScoreDropLimit::lookup(_indexEnv.getProperties()));
+    setSoftTimeoutEnabled(softtimeout::Enabled::lookup(_indexEnv.getProperties()));
+    setSoftTimeoutTailCost(softtimeout::TailCost::lookup(_indexEnv.getProperties()));
+    setSoftTimeoutFactor(softtimeout::Factor::lookup(_indexEnv.getProperties()));
 }
 
 void