lazy evaluate ranking expressions

17 files changed, 180 insertions, 118 deletions

diff --git a/searchlib/src/tests/features/beta/beta_features.cpp b/searchlib/src/tests/features/beta/beta_features.cpp
index 1bc75d6f3bb..2d992ab82e1 100644
--- a/searchlib/src/tests/features/beta/beta_features.cpp
+++ b/searchlib/src/tests/features/beta/beta_features.cpp
@@ -292,6 +292,10 @@ Test::testProximity()
                     .addScore("proximity(foo,0,1).posA", a < b ? a     : util::FEATURE_MAX)
                     .addScore("proximity(foo,0,1).posB", a < b ? b     : util::FEATURE_MIN);
                 TEST_STATE(vespalib::make_string("a=%u, b=%u", a, b).c_str());
+                { // reset lazy evaluation
+                    RankResult dummy;
+                    ft.executeOnly(dummy, 0);
+                }
                 EXPECT_TRUE(ft.execute(exp));
             }
         }
@@ -344,6 +348,10 @@ Test::testQueryCompleteness()
             RankResult exp;
             exp.addScore("queryCompleteness(foo).hit", (feature_t)(i));
             exp.addScore("queryCompleteness(foo).miss", (feature_t)(5 - i));
+            { // reset lazy evaluation
+                RankResult dummy;
+                ft.executeOnly(dummy, 0);
+            }
             EXPECT_TRUE(ft.execute(exp));
         }
     }
@@ -374,6 +382,10 @@ Test::assertQueryCompleteness(FtFeatureTest & ft, uint32_t firstOcc, uint32_t hi
     RankResult exp;
     exp.addScore("queryCompleteness(foo,5,10).hit", hits);
     exp.addScore("queryCompleteness(foo,5,10).miss", miss);
+    { // reset lazy evaluation
+        RankResult dummy;
+        ft.executeOnly(dummy, 0);
+    }
     EXPECT_TRUE(ft.execute(exp));
 }
 
@@ -473,6 +485,10 @@ Test::testFlowCompleteness()
             exp.addScore("flowCompleteness(foo).weight", 100.0);
             exp.addScore("flowCompleteness(foo).flow", i);
             TEST_STATE("run execute");
+            { // reset lazy evaluation
+                RankResult dummy;
+                ft.executeOnly(dummy, 0);
+            }
             EXPECT_TRUE(ft.execute(exp));
         }
     }
@@ -524,6 +540,10 @@ Test::testFlowCompleteness()
                         exp.addScore("flowCompleteness(foo).flow", flow);
                         TEST_STATE(vespalib::make_string("execute t0m=%u t1m=%u t2m=%u t3m=%u flow=%u",
                                         t0m, t1m, t2m, t3m, flow).c_str());
+                        { // reset lazy evaluation
+                            RankResult dummy;
+                            ft.executeOnly(dummy, 0);
+                        }
                         ASSERT_TRUE(ft.execute(exp));
                     }
                 }
diff --git a/searchlib/src/tests/features/constant/constant_test.cpp b/searchlib/src/tests/features/constant/constant_test.cpp
index d990943367b..2bce80fb190 100644
--- a/searchlib/src/tests/features/constant/constant_test.cpp
+++ b/searchlib/src/tests/features/constant/constant_test.cpp
@@ -56,25 +56,21 @@ struct ExecFixture
         setup_search_features(factory);
     }
     bool setup() { return test.setup(); }
-    const Tensor &extractTensor() {
-        const Value::CREF *value = test.resolveObjectFeature();
-        ASSERT_TRUE(value != nullptr);
-        ASSERT_TRUE(value->get().is_tensor());
-        return static_cast<const Tensor &>(*value->get().as_tensor());
+    const Tensor &extractTensor(uint32_t docid) {
+        Value::CREF value = test.resolveObjectFeature(docid);
+        ASSERT_TRUE(value.get().is_tensor());
+        return static_cast<const Tensor &>(*value.get().as_tensor());
     }
     const Tensor &executeTensor(uint32_t docId = 1) {
-        test.executeOnly(docId);
-        return extractTensor();
+        return extractTensor(docId);
     }
-    double extractDouble() {
-        const Value::CREF *value = test.resolveObjectFeature();
-        ASSERT_TRUE(value != nullptr);
-        ASSERT_TRUE(value->get().is_double());
-        return value->get().as_double();
+    double extractDouble(uint32_t docid) {
+        Value::CREF value = test.resolveObjectFeature(docid);
+        ASSERT_TRUE(value.get().is_double());
+        return value.get().as_double();
     }
     double executeDouble(uint32_t docId = 1) {
-        test.executeOnly(docId);
-        return extractDouble();
+        return extractDouble(docId);
     }
     void addTensor(const vespalib::string &name,
                    const TensorCells &cells,
diff --git a/searchlib/src/tests/features/featurebenchmark.cpp b/searchlib/src/tests/features/featurebenchmark.cpp
index dc9d94907b4..ed8af1cdf14 100644
--- a/searchlib/src/tests/features/featurebenchmark.cpp
+++ b/searchlib/src/tests/features/featurebenchmark.cpp
@@ -236,7 +236,7 @@ Benchmark::runFieldMatch(Config & cfg)
     start();
     std::cout << "**** '" << cfg.getFeature() << "' ****" << std::endl;
     for (uint32_t i = 0; i < numRuns; ++i) {
-        ft.executeOnly(0);
+        // rank evaluation is now lazy, please re-write benchmark if needed
     }
     sample();
 }
@@ -261,7 +261,7 @@ Benchmark::runRankingExpression(Config & cfg)
     start();
     std::cout << "**** '" << cfg.getFeature() << "' ****" << std::endl;
     for (uint32_t i = 0; i < numRuns; ++i) {
-        ft.executeOnly(0);
+        // rank evaluation is now lazy, please re-write benchmark if needed
     }
     sample();
 }
@@ -374,7 +374,7 @@ Benchmark::runAttributeMatch(Config & cfg)
             pos.setElementWeight(i % numDocs);
             amd->appendPosition(pos);
         }
-        ft.executeOnly(i % numDocs);
+        // rank evaluation is now lazy, please re-write benchmark if needed
     }
     sample();
 }
@@ -405,7 +405,7 @@ Benchmark::runAttribute(Config & cfg)
     start();
     std::cout << "**** '" << cfg.getFeature() << "' ****" << std::endl;
     for (uint32_t i = 0; i < numRuns; ++i) {
-        ft.executeOnly(i % numDocs);
+        // rank evaluation is now lazy, please re-write benchmark if needed
     }
     sample();
 }
@@ -457,7 +457,7 @@ Benchmark::runDotProduct(Config & cfg)
     start();
     std::cout << "**** '" << cfg.getFeature() << "' ****" << std::endl;
     for (uint32_t i = 0; i < numRuns; ++i) {
-        ft.executeOnly(i % numDocs);
+        // rank evaluation is now lazy, please re-write benchmark if needed
     }
     sample();
 }
@@ -499,7 +499,7 @@ Benchmark::runNativeAttributeMatch(Config & cfg)
             pos.setElementWeight(docId);
             amd->appendPosition(pos);
         }
-        ft.executeOnly(docId);
+        // rank evaluation is now lazy, please re-write benchmark if needed
     }
     sample();
 }
@@ -538,7 +538,7 @@ Benchmark::runNativeFieldMatch(Config & cfg)
     start();
     std::cout << "**** '" << cfg.getFeature() << "' ****" << std::endl;
     for (uint32_t i = 0; i < numRuns; ++i) {
-        ft.executeOnly(0);
+        // rank evaluation is now lazy, please re-write benchmark if needed
     }
     sample();
 }
@@ -580,7 +580,7 @@ Benchmark::runNativeProximity(Config & cfg)
     start();
     std::cout << "**** '" << cfg.getFeature() << "' ****" << std::endl;
     for (uint32_t i = 0; i < numRuns; ++i) {
-        ft.executeOnly(0);
+        // rank evaluation is now lazy, please re-write benchmark if needed
     }
     sample();
 }
diff --git a/searchlib/src/tests/features/item_raw_score/item_raw_score_test.cpp b/searchlib/src/tests/features/item_raw_score/item_raw_score_test.cpp
index 199a9fa72e3..fe093d41ba7 100644
--- a/searchlib/src/tests/features/item_raw_score/item_raw_score_test.cpp
+++ b/searchlib/src/tests/features/item_raw_score/item_raw_score_test.cpp
@@ -97,8 +97,7 @@ struct RankFixture : BlueprintFactoryFixture, IndexFixture {
         rankProgram->setup(mdl, queryEnv);
     }
     feature_t getScore(uint32_t docId) {
-        rankProgram->run(docId);
-        return *Utils::getScoreFeature(*rankProgram);
+        return Utils::getScoreFeature(*rankProgram, docId);
     }
     void setScore(TermFieldHandle handle, uint32_t docId, feature_t score) {
         rankProgram->match_data().resolveTermField(handle)->setRawScore(docId, score);
diff --git a/searchlib/src/tests/features/native_dot_product/native_dot_product_test.cpp b/searchlib/src/tests/features/native_dot_product/native_dot_product_test.cpp
index 3e3702cceec..87305cd1670 100644
--- a/searchlib/src/tests/features/native_dot_product/native_dot_product_test.cpp
+++ b/searchlib/src/tests/features/native_dot_product/native_dot_product_test.cpp
@@ -103,8 +103,7 @@ struct RankFixture : BlueprintFactoryFixture, IndexFixture {
         rankProgram->setup(mdl, queryEnv);
     }
     feature_t getScore(uint32_t docId) {
-        rankProgram->run(docId);
-        return *Utils::getScoreFeature(*rankProgram);
+        return Utils::getScoreFeature(*rankProgram, docId);
     }
     void setFooWeight(uint32_t i, uint32_t docId, int32_t index_weight) {
         ASSERT_LESS(i, fooHandles.size());
diff --git a/searchlib/src/tests/features/prod_features.cpp b/searchlib/src/tests/features/prod_features.cpp
index ad52c3ac861..4efd140b871 100644
--- a/searchlib/src/tests/features/prod_features.cpp
+++ b/searchlib/src/tests/features/prod_features.cpp
@@ -1353,7 +1353,7 @@ Test::testNow()
         ASSERT_TRUE(ft.setup());
 
         RankResult res;
-        ASSERT_TRUE(ft.executeOnly(res, 0));
+        ASSERT_TRUE(ft.executeOnly(res, 1));
         feature_t now = 15000000000;
         ASSERT_EQUAL(now, res.getScore("now"));
     }
diff --git a/searchlib/src/tests/features/prod_features_attributematch.cpp b/searchlib/src/tests/features/prod_features_attributematch.cpp
index 06b2b859709..fc69061b4ef 100644
--- a/searchlib/src/tests/features/prod_features_attributematch.cpp
+++ b/searchlib/src/tests/features/prod_features_attributematch.cpp
@@ -234,6 +234,10 @@ Test::testAttributeMatch()
         mdb->apply(1);
         exp.clear().
             addScore("attributeMatch(wsint).fieldCompleteness", 0.5f);
+        { // reset lazy evaluation
+            RankResult dummy;
+            ft.executeOnly(dummy, 0);
+        }
         ASSERT_TRUE(ft.execute(exp));
 
         // test that normalized values lies in the interval [0,1].
@@ -243,6 +247,10 @@ Test::testAttributeMatch()
         exp.clear().
             addScore("attributeMatch(wsfloat).normalizedWeight", 1).
             addScore("attributeMatch(wsfloat).normalizedWeightedWeight", 1);
+        { // reset lazy evaluation
+            RankResult dummy;
+            ft.executeOnly(dummy, 0);
+        }
         ASSERT_TRUE(ft.execute(exp));
     }
 
diff --git a/searchlib/src/tests/features/prod_features_fieldmatch.cpp b/searchlib/src/tests/features/prod_features_fieldmatch.cpp
index e26d6a92fa6..e9bafdb1c78 100644
--- a/searchlib/src/tests/features/prod_features_fieldmatch.cpp
+++ b/searchlib/src/tests/features/prod_features_fieldmatch.cpp
@@ -957,20 +957,20 @@ Test::testFieldMatchExecutorRemaining()
             ASSERT_TRUE(mdb->setFieldLength("foo", 3));
             ASSERT_TRUE(mdb->addOccurence("foo", 0, 0)); // 'a'
             ASSERT_TRUE(mdb->addOccurence("foo", 1, 1)); // 'b'
-            ASSERT_TRUE(mdb->apply(1));
+            ASSERT_TRUE(mdb->apply(2));
             RankResult rr = toRankResult("fieldMatch(foo)", "score:0.9558 matches:2");
             rr.setEpsilon(1e-4); // same as java tests
-            ASSERT_TRUE(ft.execute(rr, 1));
+            ASSERT_TRUE(ft.execute(rr, 2));
         }
         { // docid 3: "x a b"
             MatchDataBuilder::UP mdb = ft.createMatchDataBuilder();
             ASSERT_TRUE(mdb->setFieldLength("foo", 3));
             ASSERT_TRUE(mdb->addOccurence("foo", 0, 1)); // 'a'
             ASSERT_TRUE(mdb->addOccurence("foo", 1, 2)); // 'b'
-            ASSERT_TRUE(mdb->apply(2));
+            ASSERT_TRUE(mdb->apply(3));
             RankResult rr = toRankResult("fieldMatch(foo)", "score:0.9463 matches:2");
             rr.setEpsilon(1e-4); // same as java tests
-            ASSERT_TRUE(ft.execute(rr, 2));
+            ASSERT_TRUE(ft.execute(rr, 3));
         }
     }
 
@@ -1008,6 +1008,10 @@ Test::testFieldMatchExecutorRemaining()
             // add hit with query term 'b'
             mdb->getTermFieldMatchData(1, 0)->reset(1);
             ASSERT_TRUE(mdb->apply(1));
+            { // reset lazy evaluation
+                RankResult dummy;
+                ft.executeOnly(dummy, 0);
+            }
             ASSERT_TRUE(ft.execute(toRankResult("fieldMatch(foo)",
                                                 "score:0 completeness:0.475 queryCompleteness:0.5 weight:0.2 matches:2 degradedMatches:2").
                                    setEpsilon(1e-4)));
diff --git a/searchlib/src/tests/features/raw_score/raw_score_test.cpp b/searchlib/src/tests/features/raw_score/raw_score_test.cpp
index 0a15ff69318..b98c60b7c50 100644
--- a/searchlib/src/tests/features/raw_score/raw_score_test.cpp
+++ b/searchlib/src/tests/features/raw_score/raw_score_test.cpp
@@ -73,8 +73,7 @@ struct RankFixture : BlueprintFactoryFixture, IndexFixture {
         rankProgram->setup(mdl, queryEnv);
     }
     feature_t getScore(uint32_t docId) {
-        rankProgram->run(docId);
-        return *Utils::getScoreFeature(*rankProgram);
+        return Utils::getScoreFeature(*rankProgram, docId);
     }
     void setScore(TermFieldHandle handle, uint32_t docId, feature_t score) {
         rankProgram->match_data().resolveTermField(handle)->setRawScore(docId, score);
diff --git a/searchlib/src/tests/features/subqueries/subqueries_test.cpp b/searchlib/src/tests/features/subqueries/subqueries_test.cpp
index 160ec404b20..4ed3b833853 100644
--- a/searchlib/src/tests/features/subqueries/subqueries_test.cpp
+++ b/searchlib/src/tests/features/subqueries/subqueries_test.cpp
@@ -70,8 +70,7 @@ struct RankFixture : BlueprintFactoryFixture, IndexFixture {
         return handles;
     }
     feature_t getSubqueries(uint32_t docId) {
-        rankProgram->run(docId);
-        return *Utils::getScoreFeature(*rankProgram);
+        return Utils::getScoreFeature(*rankProgram, docId);
     }
     void setSubqueries(TermFieldHandle handle, uint32_t docId,
                        uint64_t subqueries) {
diff --git a/searchlib/src/tests/features/tensor/tensor_test.cpp b/searchlib/src/tests/features/tensor/tensor_test.cpp
index fd59cd8b9d7..34a5df23395 100644
--- a/searchlib/src/tests/features/tensor/tensor_test.cpp
+++ b/searchlib/src/tests/features/tensor/tensor_test.cpp
@@ -154,15 +154,13 @@ struct ExecFixture
                        { "x", "y" });
         setQueryTensorType("null", "tensor(q{})");
     }
-    const Tensor &extractTensor() {
-        const Value::CREF *value = test.resolveObjectFeature();
-        ASSERT_TRUE(value != nullptr);
-        ASSERT_TRUE(value->get().is_tensor());
-        return static_cast<const Tensor &>(*value->get().as_tensor());
+    const Tensor &extractTensor(uint32_t docid) {
+        Value::CREF value = test.resolveObjectFeature(docid);
+        ASSERT_TRUE(value.get().is_tensor());
+        return static_cast<const Tensor &>(*value.get().as_tensor());
     }
     const Tensor &execute(uint32_t docId = 1) {
-        test.executeOnly(docId);
-        return extractTensor();
+        return extractTensor(docId);
     }
 };
 
diff --git a/searchlib/src/tests/features/tensor_from_labels/tensor_from_labels_test.cpp b/searchlib/src/tests/features/tensor_from_labels/tensor_from_labels_test.cpp
index e0e6b4746a4..6f413da004c 100644
--- a/searchlib/src/tests/features/tensor_from_labels/tensor_from_labels_test.cpp
+++ b/searchlib/src/tests/features/tensor_from_labels/tensor_from_labels_test.cpp
@@ -121,15 +121,13 @@ struct ExecFixture
         test.getQueryEnv().getProperties().add("astr_query", "[d e f]");
         test.getQueryEnv().getProperties().add("aint_query", "[11 13 17]");
     }
-    const Tensor &extractTensor() {
-        const Value::CREF *value = test.resolveObjectFeature();
-        ASSERT_TRUE(value != nullptr);
-        ASSERT_TRUE(value->get().is_tensor());
-        return static_cast<const Tensor &>(*value->get().as_tensor());
+    const Tensor &extractTensor(uint32_t docid) {
+        Value::CREF value = test.resolveObjectFeature(docid);
+        ASSERT_TRUE(value.get().is_tensor());
+        return static_cast<const Tensor &>(*value.get().as_tensor());
     }
     const Tensor &execute() {
-        test.executeOnly();
-        return extractTensor();
+        return extractTensor(1);
     }
 };
 
diff --git a/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp b/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
index 839b1efec74..d8dec88c418 100644
--- a/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
+++ b/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
@@ -120,15 +120,13 @@ struct ExecFixture
     void setupQueryEnvironment() {
         test.getQueryEnv().getProperties().add("wsquery", "{d:11,e:13,f:17}");
     }
-    const Tensor &extractTensor() {
-        const Value::CREF *value = test.resolveObjectFeature();
-        ASSERT_TRUE(value != nullptr);
-        ASSERT_TRUE(value->get().is_tensor());
-        return static_cast<const Tensor &>(*value->get().as_tensor());
+    const Tensor &extractTensor(uint32_t docid) {
+        Value::CREF value = test.resolveObjectFeature(docid);
+        ASSERT_TRUE(value.get().is_tensor());
+        return static_cast<const Tensor &>(*value.get().as_tensor());
     }
     const Tensor &execute() {
-        test.executeOnly();
-        return extractTensor();
+        return extractTensor(1);
     }
 };
 
diff --git a/searchlib/src/tests/fef/featureoverride/featureoverride.cpp b/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
index 80389064a8f..e77e50a99c8 100644
--- a/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
+++ b/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
@@ -97,10 +97,10 @@ TEST_F("test decorator - transitive override", Fixture)
 
     FeatureExecutor *fe2 = &stash.create<DoubleExecutor>(3);
     fe2 = &stash.create<FeatureOverrider>(*fe2, 2, 10.0);
-    auto inputs = stash.create_array<const NumberOrObject *>(3);
-    inputs[0] = fe->outputs().get_raw(0);
-    inputs[1] = fe->outputs().get_raw(1);
-    inputs[2] = fe->outputs().get_raw(2);
+    auto inputs = stash.create_array<LazyValue>(3, nullptr);
+    inputs[0] = LazyValue(fe->outputs().get_raw(0), fe);
+    inputs[1] = LazyValue(fe->outputs().get_raw(1), fe);
+    inputs[2] = LazyValue(fe->outputs().get_raw(2), fe);
     fe2->bind_inputs(inputs);
     f.add(fe2, 3).run();
     EXPECT_EQUAL(fe2->outputs().size(), 3u);
@@ -143,9 +143,8 @@ TEST("test overrides")
     overrides.add("bogus(feature)", "10.0");
 
     rankProgram->setup(mdl, queryEnv, overrides);
-    rankProgram->run(2);
 
-    std::map<vespalib::string, feature_t> res = Utils::getAllFeatures(*rankProgram);
+    std::map<vespalib::string, feature_t> res = Utils::getAllFeatures(*rankProgram, 2);
 
     EXPECT_EQUAL(res.size(), 20u);
     EXPECT_APPROX(res["value(1)"],                               1.0, 1e-6);
diff --git a/searchlib/src/tests/fef/object_passing/object_passing_test.cpp b/searchlib/src/tests/fef/object_passing/object_passing_test.cpp
index 53f9b028e9d..d62be9b42fb 100644
--- a/searchlib/src/tests/fef/object_passing/object_passing_test.cpp
+++ b/searchlib/src/tests/fef/object_passing/object_passing_test.cpp
@@ -91,11 +91,10 @@ struct Fixture {
         Properties overrides;
         RankProgram program(resolver);
         program.setup(mdl, queryEnv, overrides);        
-        program.run(1);
         auto result = program.get_seeds();
         EXPECT_EQUAL(1u, result.num_features());
         EXPECT_TRUE(!result.is_object(0)); // verifies auto-unboxing
-        return *result.resolve_number(0);
+        return result.resolve(0).as_number(1);
     }
 
     bool verify(const vespalib::string &feature) {
diff --git a/searchlib/src/tests/fef/rank_program/rank_program_test.cpp b/searchlib/src/tests/fef/rank_program/rank_program_test.cpp
index b70b78d8d28..91c266f2745 100644
--- a/searchlib/src/tests/fef/rank_program/rank_program_test.cpp
+++ b/searchlib/src/tests/fef/rank_program/rank_program_test.cpp
@@ -13,19 +13,47 @@ using namespace search::fef;
 using namespace search::fef::test;
 using namespace search::features;
 
-size_t count_unique_features(const RankProgram &program) {
-    std::set<const NumberOrObject *> seen;
+uint32_t default_docid = 1;
+
+void maybe_insert(const LazyValue &value, std::vector<LazyValue> &seen) {
+    for (const auto &entry: seen) {
+        if (value.is_same(entry)) {
+            return;
+        }
+    }
+    seen.push_back(value);
+}
+
+std::vector<LazyValue> get_features(const RankProgram &program) {
+    std::vector<LazyValue> seen;
     auto unboxed = program.get_all_features(true);
     for (size_t i = 0; i < unboxed.num_features(); ++i) {
-        // fprintf(stderr, "seen feature (unboxed): %s\n", unboxed.name_of(i).c_str());
-        seen.insert(unboxed.resolve_raw(i));
+        maybe_insert(unboxed.resolve(i), seen);
     }
     auto maybe_boxed = program.get_all_features(false);
     for (size_t i = 0; i < maybe_boxed.num_features(); ++i) {
-        // fprintf(stderr, "seen feature (maybe boxed): %s\n", maybe_boxed.name_of(i).c_str());
-        seen.insert(maybe_boxed.resolve_raw(i));
+        maybe_insert(maybe_boxed.resolve(i), seen);
     }
-    return seen.size();
+    return seen;
+}
+
+template <typename Predicate>
+size_t count(const RankProgram &program, Predicate pred) {
+    size_t cnt = 0;
+    for (const auto &value: get_features(program)) {
+        if (pred(value)) {
+            ++cnt;
+        }
+    }
+    return cnt;
+}
+
+size_t count_features(const RankProgram &program) {
+    return count(program, [](const LazyValue &){ return true; });
+}
+
+size_t count_const_features(const RankProgram &program) {
+    return count(program, [](const LazyValue &value){ return value.is_const(); });
 }
 
 struct ImpureValueExecutor : FeatureExecutor {
@@ -51,6 +79,23 @@ struct ImpureValueBlueprint : Blueprint {
     }
 };
 
+struct DocidExecutor : FeatureExecutor {
+    void execute(uint32_t docid) override { outputs().set_number(0, docid); }
+};
+
+struct DocidBlueprint : Blueprint {
+    DocidBlueprint() : Blueprint("docid") {}
+    void visitDumpFeatures(const IIndexEnvironment &, IDumpFeatureVisitor &) const override {}
+    Blueprint::UP createInstance() const override { return Blueprint::UP(new DocidBlueprint()); }
+    bool setup(const IIndexEnvironment &, const std::vector<vespalib::string> &) override {
+        describeOutput("out", "the local document id");
+        return true;
+    }
+    FeatureExecutor &createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const override {
+        return stash.create<DocidExecutor>();
+    }
+};
+
 struct MySetup {
     BlueprintFactory factory;
     IndexEnvironment indexEnv;
@@ -63,6 +108,7 @@ struct MySetup {
         factory.addPrototype(Blueprint::SP(new ValueBlueprint()));
         factory.addPrototype(Blueprint::SP(new ImpureValueBlueprint()));
         factory.addPrototype(Blueprint::SP(new SumBlueprint()));
+        factory.addPrototype(Blueprint::SP(new DocidBlueprint()));
     }
     MySetup &add(const vespalib::string &feature) {
         resolver->addSeed(feature);
@@ -79,20 +125,16 @@ struct MySetup {
         program.setup(mdl, queryEnv, overrides);
         return *this;
     }
-    MySetup &run() {
-        program.run(1);
-        return *this;
-    }
-    double get() {
+    double get(uint32_t docid = default_docid) {
         auto result = program.get_seeds();
         EXPECT_EQUAL(1u, result.num_features());
-        return *result.resolve_number(0);
+        return result.resolve(0).as_number(docid);
     }
     double get(const vespalib::string &feature) {
         auto result = program.get_seeds();
         for (size_t i = 0; i < result.num_features(); ++i) {
             if (result.name_of(i) == feature) {
-                return *result.resolve_number(i);
+                return result.resolve(i).as_number(default_docid);
             }
         }
         return 31212.0;
@@ -101,41 +143,42 @@ struct MySetup {
         auto result = program.get_seeds();
         std::map<vespalib::string, double> result_map;
         for (size_t i = 0; i < result.num_features(); ++i) {
-            result_map[result.name_of(i)] = *result.resolve_number(i);
+            result_map[result.name_of(i)] = result.resolve(i).as_number(default_docid);
         }
         return result_map;
     }
 };
 
 TEST_F("require that simple program works", MySetup()) {
-    EXPECT_EQUAL(15.0, f1.add("mysum(value(10),ivalue(5))").compile().run().get());
+    EXPECT_EQUAL(15.0, f1.add("mysum(value(10),ivalue(5))").compile().get());
     EXPECT_EQUAL(3u, f1.program.num_executors());
-    EXPECT_EQUAL(2u, f1.program.program_size());
+    EXPECT_EQUAL(3u, count_features(f1.program));
+    EXPECT_EQUAL(1u, count_const_features(f1.program));
 }
 
-TEST_F("require that const features are calculated during setup", MySetup()) {
+TEST_F("require that const features work", MySetup()) {
     f1.add("mysum(value(10),value(5))").compile();
     EXPECT_EQUAL(15.0, f1.get());
     EXPECT_EQUAL(3u, f1.program.num_executors());
-    EXPECT_EQUAL(0u, f1.program.program_size());
+    EXPECT_EQUAL(3u, count_features(f1.program));
+    EXPECT_EQUAL(3u, count_const_features(f1.program));
 }
 
-TEST_F("require that non-const features are calculated during run", MySetup()) {
+TEST_F("require that non-const features work", MySetup()) {
     f1.add("mysum(ivalue(10),ivalue(5))").compile();
-    EXPECT_EQUAL(0.0, f1.get());
-    f1.run();
     EXPECT_EQUAL(15.0, f1.get());
     EXPECT_EQUAL(3u, f1.program.num_executors());
-    EXPECT_EQUAL(3u, f1.program.program_size());
+    EXPECT_EQUAL(3u, count_features(f1.program));
+    EXPECT_EQUAL(0u, count_const_features(f1.program));
 }
 
 TEST_F("require that a single program can calculate multiple output features", MySetup()) {
     f1.add("value(1)").add("ivalue(2)").add("ivalue(3)");
     f1.add("mysum(value(1),value(2),ivalue(3))");
-    f1.compile().run();
+    f1.compile();
     EXPECT_EQUAL(5u, f1.program.num_executors());
-    EXPECT_EQUAL(3u, f1.program.program_size());
-    EXPECT_EQUAL(5u, count_unique_features(f1.program));
+    EXPECT_EQUAL(5u, count_features(f1.program));
+    EXPECT_EQUAL(2u, count_const_features(f1.program));
     auto result = f1.all();
     EXPECT_EQUAL(4u, result.size());
     EXPECT_EQUAL(1.0, result["value(1)"]);
@@ -146,20 +189,20 @@ TEST_F("require that a single program can calculate multiple output features", M
 
 TEST_F("require that a single executor can produce multiple features", MySetup()) {
     f1.add("mysum(value(1,2,3).0,value(1,2,3).1,value(1,2,3).2)");
-    EXPECT_EQUAL(6.0, f1.compile().run().get());
+    EXPECT_EQUAL(6.0, f1.compile().get());
     EXPECT_EQUAL(2u, f1.program.num_executors());
-    EXPECT_EQUAL(0u, f1.program.program_size());
-    EXPECT_EQUAL(4u, count_unique_features(f1.program));
+    EXPECT_EQUAL(4u, count_features(f1.program));
+    EXPECT_EQUAL(4u, count_const_features(f1.program));
 }
 
 TEST_F("require that feature values can be overridden", MySetup()) {
     f1.add("value(1)").add("ivalue(2)").add("ivalue(3)");
     f1.add("mysum(value(1),value(2),ivalue(3))");
     f1.override("value(2)", 20.0).override("ivalue(3)", 30.0);
-    f1.compile().run();
+    f1.compile();
     EXPECT_EQUAL(5u, f1.program.num_executors());
-    EXPECT_EQUAL(3u, f1.program.program_size());
-    EXPECT_EQUAL(5u, count_unique_features(f1.program));
+    EXPECT_EQUAL(5u, count_features(f1.program));
+    EXPECT_EQUAL(2u, count_const_features(f1.program));
     auto result = f1.all();
     EXPECT_EQUAL(4u, result.size());
     EXPECT_EQUAL(1.0, result["value(1)"]);
@@ -168,4 +211,14 @@ TEST_F("require that feature values can be overridden", MySetup()) {
     EXPECT_EQUAL(51.0, result["mysum(value(1),value(2),ivalue(3))"]);    
 }
 
+TEST_F("require that the rank program can calculate scores for multiple documents", MySetup()) {
+    f1.add("mysum(value(10),docid)").compile();
+    EXPECT_EQUAL(3u, count_features(f1.program));
+    EXPECT_EQUAL(1u, count_const_features(f1.program));
+    EXPECT_EQUAL(f1.get(1), 11.0);
+    EXPECT_EQUAL(f1.get(2), 12.0);
+    EXPECT_EQUAL(f1.get(3), 13.0);
+    EXPECT_EQUAL(f1.get(1), 11.0);
+}
+
 TEST_MAIN() { TEST_RUN_ALL(); }
diff --git a/searchlib/src/tests/ranksetup/ranksetup_test.cpp b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
index 22c6478aeb9..fd34e030d33 100644
--- a/searchlib/src/tests/ranksetup/ranksetup_test.cpp
+++ b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
@@ -103,7 +103,7 @@ public:
         _initRank(initRank), _finalRank(finalRank), _rankEnv(rankEnv), _layout(),
         _rs(), _firstPhaseProgram(), _secondPhaseProgram() {}
     bool setup();
-    RankResult execute(uint32_t docId = 0);
+    RankResult execute(uint32_t docId = 1);
 };
 
 bool
@@ -136,12 +136,10 @@ RankResult
 RankExecutor::execute(uint32_t docId)
 {
     RankResult result;
-    _firstPhaseProgram->run(docId);
-    result.addScore(_initRank, *Utils::getScoreFeature(*_firstPhaseProgram));
+    result.addScore(_initRank, Utils::getScoreFeature(*_firstPhaseProgram, docId));
 
     if (_secondPhaseProgram.get() != nullptr) {
-        _secondPhaseProgram->run(docId);
-        result.addScore(_finalRank, *Utils::getScoreFeature(*_secondPhaseProgram));
+        result.addScore(_finalRank, Utils::getScoreFeature(*_secondPhaseProgram, docId));
     }
 
     return result;
@@ -198,8 +196,7 @@ FeatureDumper::setup()
 RankResult
 FeatureDumper::dump()
 {
-    _rankProgram->run(1);
-    std::map<vespalib::string, feature_t> features = Utils::getSeedFeatures(*_rankProgram);
+    std::map<vespalib::string, feature_t> features = Utils::getSeedFeatures(*_rankProgram, 1);
     RankResult retval;
     for (auto itr = features.begin(); itr != features.end(); ++itr) {
         retval.addScore(itr->first, itr->second);
@@ -230,10 +227,10 @@ private:
     void testCompilation();
     void testRankSetup();
     bool testExecution(const vespalib::string & initRank, feature_t initScore,
-                       const vespalib::string & finalRank = "", feature_t finalScore = 0.0f, uint32_t docId = 0);
+                       const vespalib::string & finalRank = "", feature_t finalScore = 0.0f, uint32_t docId = 1);
     bool testExecution(const RankEnvironment &rankEnv,
                        const vespalib::string & initRank, feature_t initScore,
-                       const vespalib::string & finalRank = "", feature_t finalScore = 0.0f, uint32_t docId = 0);
+                       const vespalib::string & finalRank = "", feature_t finalScore = 0.0f, uint32_t docId = 1);
     void testExecution();
     void testFeatureDump();
 
@@ -582,7 +579,7 @@ RankSetupTest::testExecution()
     { // static rank executor
         vespalib::string sr1 = "staticrank(staticrank1)";
         vespalib::string sr2 = "staticrank(staticrank2)";
-        for (uint32_t i = 0; i < 5; ++i) {
+        for (uint32_t i = 1; i < 5; ++i) {
             EXPECT_TRUE(testExecution(sr1, static_cast<feature_t>(i + 100),
                                      sr2, static_cast<feature_t>(i + 200), i));
         }
@@ -786,21 +783,18 @@ RankSetupTest::testFeatureNormalization()
         secondPhaseProgram->setup(layout, queryEnv);
         summaryProgram->setup(layout, queryEnv);
 
-        firstPhaseProgram->run(1);
-        EXPECT_APPROX(2.0, *Utils::getScoreFeature(*firstPhaseProgram), 0.001);
-        secondPhaseProgram->run(1);
-        EXPECT_APPROX(4.0, *Utils::getScoreFeature(*secondPhaseProgram), 0.001);
-        summaryProgram->run(1);
+        EXPECT_APPROX(2.0, Utils::getScoreFeature(*firstPhaseProgram, 1), 0.001);
+        EXPECT_APPROX(4.0, Utils::getScoreFeature(*secondPhaseProgram, 1), 0.001);
 
         { // rank seed features
-            std::map<vespalib::string, feature_t> actual = Utils::getSeedFeatures(*summaryProgram);
+            std::map<vespalib::string, feature_t> actual = Utils::getSeedFeatures(*summaryProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["mysum(value(5),value(5))"] = 10.0;
             exp["mysum(\"value( 5 )\",\"value( 5 )\")"] = 10.0;
             TEST_DO(checkFeatures(exp, actual));
         }
         { // all rank features (1. phase)
-            std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*firstPhaseProgram);
+            std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*firstPhaseProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["value(1)"] = 1.0;
             exp["value(1).0"] = 1.0;
@@ -809,7 +803,7 @@ RankSetupTest::testFeatureNormalization()
             TEST_DO(checkFeatures(exp, actual));
         }
         { // all rank features (2. phase)
-            std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*secondPhaseProgram);
+            std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*secondPhaseProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["value(2)"] = 2.0;
             exp["value(2).0"] = 2.0;
@@ -818,7 +812,7 @@ RankSetupTest::testFeatureNormalization()
             TEST_DO(checkFeatures(exp, actual));
         }
         { // all rank features (summary)
-            std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*summaryProgram);
+            std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*summaryProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["value(5)"] = 5.0;
             exp["value(5).0"] = 5.0;
@@ -835,10 +829,9 @@ RankSetupTest::testFeatureNormalization()
         QueryEnvironment queryEnv;
         RankProgram::UP rankProgram = rankSetup.create_dump_program();
         rankProgram->setup(layout, queryEnv);
-        rankProgram->run(1);
 
         { // dump seed features
-            std::map<vespalib::string, feature_t> actual = Utils::getSeedFeatures(*rankProgram);
+            std::map<vespalib::string, feature_t> actual = Utils::getSeedFeatures(*rankProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["mysum(value(10),value(10))"] = 20.0;
             exp["mysum(\"value( 10 )\",\"value( 10 )\")"] = 20.0;
@@ -846,7 +839,7 @@ RankSetupTest::testFeatureNormalization()
         }
 
         { // all dump features
-            std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*rankProgram);
+            std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*rankProgram, 1);
             std::map<vespalib::string, feature_t> exp;
 
             exp["value(10)"] = 10.0;