Rename existing rank drop limit and rank score drop limit to

first phase rank score drop limit.
Stop using std::isnan to mark no value.

6 files changed, 44 insertions, 34 deletions

diff --git a/searchlib/src/tests/fef/properties/properties_test.cpp b/searchlib/src/tests/fef/properties/properties_test.cpp
index d3890c8f9fc..5e9c3a25ef8 100644
--- a/searchlib/src/tests/fef/properties/properties_test.cpp
+++ b/searchlib/src/tests/fef/properties/properties_test.cpp
@@ -409,16 +409,18 @@ TEST(PropertiesTest, test_stuff)
             EXPECT_EQ(hitcollector::EstimateLimit::lookup(p), 50u);
         }
         { // vespa.hitcollector.rankscoredroplimit
-            EXPECT_EQ(hitcollector::RankScoreDropLimit::NAME, vespalib::string("vespa.hitcollector.rankscoredroplimit"));
-            search::feature_t got1 = hitcollector::RankScoreDropLimit::DEFAULT_VALUE;
-            EXPECT_TRUE(got1 != got1);
-            Properties p;
-            search::feature_t got2= hitcollector::RankScoreDropLimit::lookup(p);
-            EXPECT_TRUE(got2 != got2);
+            EXPECT_EQ(vespalib::string("vespa.hitcollector.rankscoredroplimit"), hitcollector::FirstPhaseRankScoreDropLimit::NAME);
+            Properties p;
+            auto got2 = hitcollector::FirstPhaseRankScoreDropLimit::lookup(p);
+            EXPECT_EQ(std::optional<search::feature_t>(), got2);
+            got2 = hitcollector::FirstPhaseRankScoreDropLimit::lookup(p, std::nullopt);
+            EXPECT_EQ(std::optional<search::feature_t>(), got2);
+            got2 = hitcollector::FirstPhaseRankScoreDropLimit::lookup(p, 4.5);
+            EXPECT_EQ(std::optional<search::feature_t>(4.5), got2);
             p.add("vespa.hitcollector.rankscoredroplimit", "-123456789.12345");
-            EXPECT_EQ(hitcollector::RankScoreDropLimit::lookup(p), -123456789.12345);
+            EXPECT_EQ(std::optional<search::feature_t>(-123456789.12345), hitcollector::FirstPhaseRankScoreDropLimit::lookup(p));
             p.clear().add("vespa.hitcollector.rankscoredroplimit", "123456789.12345");
-            EXPECT_EQ(hitcollector::RankScoreDropLimit::lookup(p), 123456789.12345);
+            EXPECT_EQ(std::optional<search::feature_t>(123456789.12345), hitcollector::FirstPhaseRankScoreDropLimit::lookup(p));
         }
         { // vespa.fieldweight.
             EXPECT_EQ(FieldWeight::BASE_NAME, vespalib::string("vespa.fieldweight."));
diff --git a/searchlib/src/tests/ranksetup/ranksetup_test.cpp b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
index 348326c3936..595b2065feb 100644
--- a/searchlib/src/tests/ranksetup/ranksetup_test.cpp
+++ b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
@@ -525,7 +525,7 @@ void RankSetupTest::testRankSetup()
     env.getProperties().add(hitcollector::ArraySize::NAME, "60");
     env.getProperties().add(hitcollector::EstimatePoint::NAME, "70");
     env.getProperties().add(hitcollector::EstimateLimit::NAME, "80");
-    env.getProperties().add(hitcollector::RankScoreDropLimit::NAME, "90.5");
+    env.getProperties().add(hitcollector::FirstPhaseRankScoreDropLimit::NAME, "90.5");
     env.getProperties().add(mutate::on_match::Attribute::NAME, "a");
     env.getProperties().add(mutate::on_match::Operation::NAME, "+=3");
     env.getProperties().add(mutate::on_first_phase::Attribute::NAME, "b");
@@ -567,7 +567,7 @@ void RankSetupTest::testRankSetup()
     EXPECT_EQUAL(rs.getArraySize(), 60u);
     EXPECT_EQUAL(rs.getEstimatePoint(), 70u);
     EXPECT_EQUAL(rs.getEstimateLimit(), 80u);
-    EXPECT_EQUAL(rs.getRankScoreDropLimit(), 90.5);
+    EXPECT_EQUAL(rs.get_first_phase_rank_score_drop_limit().value(), 90.5);
     EXPECT_EQUAL(rs.getMutateOnMatch()._attribute, "a");
     EXPECT_EQUAL(rs.getMutateOnMatch()._operation, "+=3");
     EXPECT_EQUAL(rs.getMutateOnFirstPhase()._attribute, "b");
diff --git a/searchlib/src/vespa/searchlib/fef/indexproperties.cpp b/searchlib/src/vespa/searchlib/fef/indexproperties.cpp
index 1f88c34bef3..516a09e31b4 100644
--- a/searchlib/src/vespa/searchlib/fef/indexproperties.cpp
+++ b/searchlib/src/vespa/searchlib/fef/indexproperties.cpp
@@ -36,14 +36,20 @@ lookupStringVector(const Properties &props, const vespalib::string &name,
     return defaultValue;
 }
 
-double
-lookupDouble(const Properties &props, const vespalib::string &name, double defaultValue)
+std::optional<double>
+lookup_opt_double(const Properties &props, vespalib::stringref name, std::optional<double> default_value)
 {
     Property p = props.lookup(name);
     if (p.found()) {
         return vespalib::locale::c::strtod(p.get().c_str(), nullptr);
     }
-    return defaultValue;
+    return default_value;
+}
+
+double
+lookupDouble(const Properties &props, const vespalib::string &name, double defaultValue)
+{
+    return lookup_opt_double(props, name, defaultValue).value();
 }
 
 uint32_t
@@ -683,19 +689,19 @@ EstimateLimit::lookup(const Properties &props)
     return lookupUint32(props, NAME, DEFAULT_VALUE);
 }
 
-const vespalib::string RankScoreDropLimit::NAME("vespa.hitcollector.rankscoredroplimit");
-const feature_t RankScoreDropLimit::DEFAULT_VALUE(-std::numeric_limits<feature_t>::quiet_NaN());
+const vespalib::string FirstPhaseRankScoreDropLimit::NAME("vespa.hitcollector.rankscoredroplimit");
+const std::optional<feature_t> FirstPhaseRankScoreDropLimit::DEFAULT_VALUE(std::nullopt);
 
-feature_t
-RankScoreDropLimit::lookup(const Properties &props)
+std::optional<feature_t>
+FirstPhaseRankScoreDropLimit::lookup(const Properties &props)
 {
     return lookup(props, DEFAULT_VALUE);
 }
 
-feature_t
-RankScoreDropLimit::lookup(const Properties &props, feature_t defaultValue)
+std::optional<feature_t>
+FirstPhaseRankScoreDropLimit::lookup(const Properties &props, std::optional<feature_t> default_value)
 {
-    return lookupDouble(props, NAME, defaultValue);
+    return lookup_opt_double(props, NAME, default_value);
 }
 
 } // namspace hitcollector
diff --git a/searchlib/src/vespa/searchlib/fef/indexproperties.h b/searchlib/src/vespa/searchlib/fef/indexproperties.h
index d047eb13347..bf965e6805a 100644
--- a/searchlib/src/vespa/searchlib/fef/indexproperties.h
+++ b/searchlib/src/vespa/searchlib/fef/indexproperties.h
@@ -5,6 +5,7 @@
 #include <vespa/searchlib/common/feature.h>
 #include <vespa/vespalib/fuzzy/fuzzy_matching_algorithm.h>
 #include <vespa/vespalib/stllike/string.h>
+#include <optional>
 #include <vector>
 
 namespace search::fef { class Properties; }
@@ -562,17 +563,17 @@ namespace hitcollector {
     };
 
     /**
-     * Property for the rank score drop limit used in parallel query evaluation.
-     * Drop a hit if the rank score <= drop limit.
+     * Property for the first phase rank score drop limit used in parallel
+     * query evaluation.
+     * Drop a hit if the first phase rank score <= drop limit.
      **/
-    struct RankScoreDropLimit {
+    struct FirstPhaseRankScoreDropLimit {
         static const vespalib::string NAME;
-        static const feature_t DEFAULT_VALUE;
-        static feature_t lookup(const Properties &props);
-        static feature_t lookup(const Properties &props, feature_t defaultValue);
+        static const std::optional<feature_t> DEFAULT_VALUE;
+        static std::optional<feature_t> lookup(const Properties &props);
+        static std::optional<feature_t> lookup(const Properties &props, std::optional<feature_t> default_value);
     };
 
-
 } // namespace hitcollector
 
 /**
diff --git a/searchlib/src/vespa/searchlib/fef/ranksetup.cpp b/searchlib/src/vespa/searchlib/fef/ranksetup.cpp
index ba5abb35141..85c183f140c 100644
--- a/searchlib/src/vespa/searchlib/fef/ranksetup.cpp
+++ b/searchlib/src/vespa/searchlib/fef/ranksetup.cpp
@@ -50,7 +50,7 @@ RankSetup::RankSetup(const BlueprintFactory &factory, const IIndexEnvironment &i
       _degradationMaxFilterCoverage(1.0),
       _degradationSamplePercentage(0.2),
       _degradationPostFilterMultiplier(1.0),
-      _rankScoreDropLimit(0),
+      _first_phase_rank_score_drop_limit(),
       _match_features(),
       _summaryFeatures(),
       _dumpFeatures(),
@@ -120,7 +120,7 @@ RankSetup::configure()
     setDiversityCutoffStrategy(matchphase::DiversityCutoffStrategy::lookup(_indexEnv.getProperties()));
     setEstimatePoint(hitcollector::EstimatePoint::lookup(_indexEnv.getProperties()));
     setEstimateLimit(hitcollector::EstimateLimit::lookup(_indexEnv.getProperties()));
-    setRankScoreDropLimit(hitcollector::RankScoreDropLimit::lookup(_indexEnv.getProperties()));
+    set_first_phase_rank_score_drop_limit(hitcollector::FirstPhaseRankScoreDropLimit::lookup(_indexEnv.getProperties()));
     setSoftTimeoutEnabled(softtimeout::Enabled::lookup(_indexEnv.getProperties()));
     setSoftTimeoutTailCost(softtimeout::TailCost::lookup(_indexEnv.getProperties()));
     set_global_filter_lower_limit(matching::GlobalFilterLowerLimit::lookup(_indexEnv.getProperties()));
diff --git a/searchlib/src/vespa/searchlib/fef/ranksetup.h b/searchlib/src/vespa/searchlib/fef/ranksetup.h
index f20ecd4b42b..4fe35250253 100644
--- a/searchlib/src/vespa/searchlib/fef/ranksetup.h
+++ b/searchlib/src/vespa/searchlib/fef/ranksetup.h
@@ -9,6 +9,7 @@
 #include "rank_program.h"
 #include <vespa/searchlib/common/stringmap.h>
 #include <vespa/vespalib/fuzzy/fuzzy_matching_algorithm.h>
+#include <optional>
 
 namespace search::fef {
 
@@ -59,7 +60,7 @@ private:
     double                   _degradationMaxFilterCoverage;
     double                   _degradationSamplePercentage;
     double                   _degradationPostFilterMultiplier;
-    feature_t                _rankScoreDropLimit;
+    std::optional<feature_t> _first_phase_rank_score_drop_limit;
     std::vector<vespalib::string> _match_features;
     std::vector<vespalib::string> _summaryFeatures;
     std::vector<vespalib::string> _dumpFeatures;
@@ -332,18 +333,18 @@ public:
     uint32_t getEstimateLimit() const { return _estimateLimit; }
 
     /**
-     * Sets the rank score drop limit to be used in parallel query evaluation.
+     * Sets the first phase rank score drop limit to be used in parallel query evaluation.
      *
-     * @param rankScoreDropLimit the rank score drop limit
+     * @param value the first phase rank score drop limit
      **/
-    void setRankScoreDropLimit(feature_t rankScoreDropLimit) { _rankScoreDropLimit = rankScoreDropLimit; }
+    void set_first_phase_rank_score_drop_limit(std::optional<feature_t> value) { _first_phase_rank_score_drop_limit = value; }
 
     /**
      * Returns the rank score drop limit to be used in parallel query evaluation.
      *
      * @return the rank score drop limit
      **/
-    feature_t getRankScoreDropLimit() const { return _rankScoreDropLimit; }
+    std::optional<feature_t> get_first_phase_rank_score_drop_limit() const noexcept { return _first_phase_rank_score_drop_limit; }
 
     /**
      * This method may be used to indicate that certain features