Merge pull request #31282 from vespa-engine/balder/wire-parallel-heap-to-simple-weakand

- Wire in a common shared heap for WeakAnd.

20 files changed, 233 insertions, 192 deletions

diff --git a/searchlib/src/tests/queryeval/blueprint/blueprint_test.cpp b/searchlib/src/tests/queryeval/blueprint/blueprint_test.cpp
index 485410e0eba..b0234010f77 100644
--- a/searchlib/src/tests/queryeval/blueprint/blueprint_test.cpp
+++ b/searchlib/src/tests/queryeval/blueprint/blueprint_test.cpp
@@ -13,7 +13,7 @@
 LOG_SETUP("blueprint_test");
 
 using namespace search::queryeval;
-using namespace search::fef;
+using MatchData = search::fef::MatchData;
 
 namespace {
 
@@ -44,9 +44,7 @@ public:
     }
 
     SearchIterator::UP
-    createIntermediateSearch(MultiSearch::Children subSearches,
-                             MatchData &md) const override
-    {
+    createIntermediateSearch(MultiSearch::Children subSearches, MatchData &md) const override {
         return std::make_unique<MySearch>("or", std::move(subSearches), &md, strict());
     }
     SearchIteratorUP createFilterSearch(FilterConstraint constraint) const override {
@@ -63,9 +61,7 @@ class OtherOr : public OrBlueprint
 private:
 public:
     SearchIterator::UP
-    createIntermediateSearch(MultiSearch::Children subSearches,
-                             MatchData &md) const override
-    {
+    createIntermediateSearch(MultiSearch::Children subSearches, MatchData &md) const override {
         return std::make_unique<MySearch>("or", std::move(subSearches), &md, strict());
     }
 
@@ -89,9 +85,7 @@ public:
     }
 
     SearchIterator::UP
-    createIntermediateSearch(MultiSearch::Children subSearches,
-                             MatchData &md) const override
-    {
+    createIntermediateSearch(MultiSearch::Children subSearches, MatchData &md) const override {
         return std::make_unique<MySearch>("and", std::move(subSearches), &md, strict());
     }
 
@@ -106,9 +100,7 @@ class OtherAnd : public AndBlueprint
 private:
 public:
     SearchIterator::UP
-    createIntermediateSearch(MultiSearch::Children subSearches,
-                             MatchData &md) const override
-    {
+    createIntermediateSearch(MultiSearch::Children subSearches, MatchData &md) const override {
         return std::make_unique<MySearch>("and", std::move(subSearches), &md, strict());
     }
 
@@ -121,9 +113,7 @@ class OtherAndNot : public AndNotBlueprint
 {
 public:
     SearchIterator::UP
-    createIntermediateSearch(MultiSearch::Children subSearches,
-                             MatchData &md) const override
-    {
+    createIntermediateSearch(MultiSearch::Children subSearches, MatchData &md) const override {
         return std::make_unique<MySearch>("andnot", std::move(subSearches), &md, strict());
     }
 
diff --git a/searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp b/searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp
index db0fe76b7af..e74fefac70e 100644
--- a/searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp
+++ b/searchlib/src/tests/queryeval/iterator_benchmark/iterator_benchmark_test.cpp
@@ -13,13 +13,13 @@
 #include <vector>
 
 using namespace search::attribute;
-using namespace search::fef;
 using namespace search::queryeval::test;
 using namespace search::queryeval;
 using namespace search;
 using namespace vespalib;
 
 using search::index::Schema;
+using search::fef::MatchData;
 
 using vespalib::make_string_short::fmt;
 
diff --git a/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp b/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp
index 2bd560637d2..996cd448f44 100644
--- a/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp
+++ b/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp
@@ -68,8 +68,8 @@ struct TestHeap : public WeakAndHeap
 {
     ScoresHistory history;
 
-    TestHeap(uint32_t scoresToTrack_) : WeakAndHeap(scoresToTrack_), history() {}
-    virtual void adjust(score_t *begin, score_t *end) override {
+    explicit TestHeap(uint32_t scoresToTrack_) : WeakAndHeap(scoresToTrack_), history() {}
+    void adjust(score_t *begin, score_t *end) override {
         Scores scores;
         for (score_t *itr = begin; itr != end; ++itr) {
             scores.add(*itr);
@@ -87,8 +87,8 @@ struct WandTestSpec : public WandSpec
     TermFieldMatchData rootMatchData;
     MatchParams matchParams;
 
-    WandTestSpec(uint32_t scoresToTrack, uint32_t scoresAdjustFrequency = 1,
-                 score_t scoreThreshold = 0, double thresholdBoostFactor = 1);
+    explicit WandTestSpec(uint32_t scoresToTrack, uint32_t scoresAdjustFrequency = 1,
+                          score_t scoreThreshold = 0, double thresholdBoostFactor = 1);
     ~WandTestSpec();
     SearchIterator::UP create() {
         MatchData::UP childrenMatchData = createMatchData();
@@ -114,7 +114,7 @@ WandTestSpec<HeapType>::WandTestSpec(uint32_t scoresToTrack, uint32_t scoresAdju
 {}
 
 template <typename HeapType>
-WandTestSpec<HeapType>::~WandTestSpec() {}
+WandTestSpec<HeapType>::~WandTestSpec() = default;
 
 using WandSpecWithTestHeap = WandTestSpec<TestHeap>;
 using WandSpecWithRealHeap = WandTestSpec<SharedWeakAndPriorityQueue>;
@@ -137,8 +137,8 @@ SimpleResult
 asSimpleResult(const FakeResult &result)
 {
     SimpleResult retval;
-    for (size_t i = 0; i < result.inspect().size(); ++i) {
-        retval.addHit(result.inspect()[i].docId);
+    for (const auto & doc : result.inspect()) {
+        retval.addHit(doc.docId);
     }
     return retval;
 }
@@ -152,26 +152,26 @@ struct WandBlueprintSpec
     FakeRequestContext requestContext;
 
     WandBlueprintSpec &add(const std::string &token, int32_t weight) {
-        tokens.push_back(std::make_pair(token, weight));
+        tokens.emplace_back(token, weight);
         return *this;
     }
 
     Node::UP createNode(uint32_t scoresToTrack = 100,
                         score_t scoreThreshold = 0,
                         double thresholdBoostFactor = 1) const {
-        SimpleWandTerm *node = new SimpleWandTerm(tokens.size(), "view", 0, Weight(0),
-                                                  scoresToTrack, scoreThreshold, thresholdBoostFactor);
-        for (size_t i = 0; i < tokens.size(); ++i) {
-            node->addTerm(tokens[i].first, Weight(tokens[i].second));
+        auto node = std::make_unique<SimpleWandTerm>(tokens.size(), "view", 0, Weight(0),
+                                                     scoresToTrack, scoreThreshold, thresholdBoostFactor);
+        for (const auto & token : tokens) {
+            node->addTerm(token.first, Weight(token.second));
         }
-        return Node::UP(node);
+        return node;
     }
 
     Blueprint::UP blueprint(Searchable &searchable, const std::string &field, const search::query::Node &term) const {
         FieldSpecList fields;
         fields.add(FieldSpec(field, fieldId, handle));
         Blueprint::UP bp = searchable.createBlueprint(requestContext, fields, term);
-        EXPECT_TRUE(dynamic_cast<ParallelWeakAndBlueprint*>(bp.get()) != 0);
+        EXPECT_TRUE(dynamic_cast<ParallelWeakAndBlueprint*>(bp.get()) != nullptr);
         return bp;
     }
 
@@ -182,7 +182,7 @@ struct WandBlueprintSpec
         bp->basic_plan(true, docIdLimit);
         bp->fetchPostings(ExecuteInfo::FULL);
         SearchIterator::UP sb = bp->createSearch(*md);
-        EXPECT_TRUE(dynamic_cast<ParallelWeakAndSearch*>(sb.get()) != 0);
+        EXPECT_TRUE(dynamic_cast<ParallelWeakAndSearch*>(sb.get()) != nullptr);
         return sb;
     }
 
@@ -197,7 +197,7 @@ struct WandBlueprintSpec
         bp->basic_plan(true, docIdLimit);
         bp->fetchPostings(ExecuteInfo::FULL);
         SearchIterator::UP sb = bp->createSearch(*md);
-        EXPECT_TRUE(dynamic_cast<ParallelWeakAndSearch*>(sb.get()) != 0);
+        EXPECT_TRUE(dynamic_cast<ParallelWeakAndSearch*>(sb.get()) != nullptr);
         return doSearch(*sb, *md->resolveTermField(handle));
     }
 };
@@ -258,7 +258,7 @@ struct AlgoSameScoreFixture : public FixtureBase
 
 struct AlgoScoreThresholdFixture : public FixtureBase
 {
-    AlgoScoreThresholdFixture(score_t scoreThreshold) : FixtureBase(3, 1, scoreThreshold) {
+    explicit AlgoScoreThresholdFixture(score_t scoreThreshold) : FixtureBase(3, 1, scoreThreshold) {
         spec.leaf(LeafSpec("A", 1).doc(1, 10).doc(2, 30));
         spec.leaf(LeafSpec("B", 2).doc(1, 20).doc(3, 40));
         prepare();
@@ -267,7 +267,7 @@ struct AlgoScoreThresholdFixture : public FixtureBase
 
 struct AlgoLargeScoresFixture : public FixtureBase
 {
-    AlgoLargeScoresFixture(score_t scoreThreshold) : FixtureBase(3, 1, scoreThreshold) {
+    explicit AlgoLargeScoresFixture(score_t scoreThreshold) : FixtureBase(3, 1, scoreThreshold) {
         spec.leaf(LeafSpec("A", 60000).doc(1, 60000).doc(2, 70000));
         spec.leaf(LeafSpec("B", 70000).doc(1, 80000).doc(3, 90000));
         prepare();
@@ -276,7 +276,7 @@ struct AlgoLargeScoresFixture : public FixtureBase
 
 struct AlgoExhaustPastFixture : public FixtureBase
 {
-    AlgoExhaustPastFixture(score_t scoreThreshold) : FixtureBase(3, 1, scoreThreshold) {
+    explicit AlgoExhaustPastFixture(score_t scoreThreshold) : FixtureBase(3, 1, scoreThreshold) {
         spec.leaf(LeafSpec("A", 1).doc(1, 20).doc(3, 40).doc(5, 10));
         spec.leaf(LeafSpec("B", 1).doc(5, 10));
         spec.leaf(LeafSpec("C", 1).doc(5, 10));
@@ -449,11 +449,11 @@ struct BlueprintFixtureBase
 };
 
 BlueprintFixtureBase::BlueprintFixtureBase() : spec(), searchable() {}
-BlueprintFixtureBase::~BlueprintFixtureBase() {}
+BlueprintFixtureBase::~BlueprintFixtureBase() = default;
 
 struct BlueprintHitsFixture : public BlueprintFixtureBase
 {
-    FakeResult createResult(size_t hits) {
+    static FakeResult createResult(size_t hits) {
         FakeResult result;
         for (size_t i = 0; i < hits; ++i) {
             result.doc(i + 1);
@@ -479,7 +479,7 @@ struct BlueprintHitsFixture : public BlueprintFixtureBase
 struct ThresholdBoostFixture : public FixtureBase
 {
     FakeResult result;
-    ThresholdBoostFixture(double boost) : FixtureBase(1, 1, 800, boost) {
+    explicit ThresholdBoostFixture(double boost) : FixtureBase(1, 1, 800, boost) {
         spec.leaf(LeafSpec("A").doc(1, 10));
         spec.leaf(LeafSpec("B").doc(2, 20));
         spec.leaf(LeafSpec("C").doc(3, 30));
@@ -532,7 +532,7 @@ TEST(ParallelWeakAndTest, require_that_blueprint_picks_up_docid_limit)
     BlueprintFixture f;
     Node::UP term = f.spec.createNode(57, 67, 77.7);
     Blueprint::UP bp = f.blueprint(*term);
-    const ParallelWeakAndBlueprint * pbp = dynamic_cast<const ParallelWeakAndBlueprint *>(bp.get());
+    const auto * pbp = dynamic_cast<const ParallelWeakAndBlueprint *>(bp.get());
     EXPECT_EQ(0u, pbp->get_docid_limit());
     bp->setDocIdLimit(1000);
     EXPECT_EQ(1000u, pbp->get_docid_limit());
@@ -543,7 +543,7 @@ TEST(ParallelWeakAndTest, require_that_scores_to_track_score_threshold_and_thres
     BlueprintFixture f;
     Node::UP term = f.spec.createNode(57, 67, 77.7);
     Blueprint::UP bp = f.blueprint(*term);
-    const ParallelWeakAndBlueprint * pbp = dynamic_cast<const ParallelWeakAndBlueprint *>(bp.get());
+    const auto * pbp = dynamic_cast<const ParallelWeakAndBlueprint *>(bp.get());
     EXPECT_EQ(57u, pbp->getScores().getScoresToTrack());
     EXPECT_EQ(67u, pbp->getScoreThreshold());
     EXPECT_EQ(77.7, pbp->getThresholdBoostFactor());
@@ -708,7 +708,7 @@ SearchIterator::UP create_wand(bool use_dww,
 
 class Verifier : public search::test::DwwIteratorChildrenVerifier {
 public:
-    Verifier(bool use_dww) : _use_dww(use_dww) { }
+    explicit Verifier(bool use_dww) : _use_dww(use_dww) { }
 private:
     SearchIterator::UP create(bool strict) const override {
         MatchParams match_params(_dummy_heap, _dummy_heap.getMinScore(), 1.0, 1);
diff --git a/searchlib/src/tests/queryeval/sourceblender/sourceblender_test.cpp b/searchlib/src/tests/queryeval/sourceblender/sourceblender_test.cpp
index b84cb02a357..b2a1f6a645a 100644
--- a/searchlib/src/tests/queryeval/sourceblender/sourceblender_test.cpp
+++ b/searchlib/src/tests/queryeval/sourceblender/sourceblender_test.cpp
@@ -7,15 +7,14 @@
 #include <vespa/searchlib/queryeval/leaf_blueprints.h>
 #define ENABLE_GTEST_MIGRATION
 #include <vespa/searchlib/test/searchiteratorverifier.h>
-#include <vespa/searchlib/common/bitvectoriterator.h>
 #include <vespa/searchlib/attribute/fixedsourceselector.h>
 #include <vespa/searchlib/fef/matchdata.h>
 #include <vespa/vespalib/gtest/gtest.h>
 
 using namespace search::queryeval;
-using namespace search::fef;
 using namespace search;
 using std::make_unique;
+using search::fef::MatchData;
 
 /**
  * Proxy search used to verify unpack pattern
@@ -27,24 +26,24 @@ private:
     SimpleResult   _unpacked;
 
 protected:
-    virtual void doSeek(uint32_t docid) override {
+    void doSeek(uint32_t docid) override {
         _search->seek(docid);
         setDocId(_search->getDocId());
     }
-    virtual void doUnpack(uint32_t docid) override {
+    void doUnpack(uint32_t docid) override {
         _unpacked.addHit(docid);
         _search->unpack(docid);
     }
 
 public:
-    UnpackChecker(SearchIterator *search) : _search(search), _unpacked() {}
+    explicit UnpackChecker(SearchIterator *search) : _search(search), _unpacked() {}
     const SimpleResult &getUnpacked() const { return _unpacked; }
 };
 
 class MySelector : public search::FixedSourceSelector
 {
 public:
-    MySelector(int defaultSource) : search::FixedSourceSelector(defaultSource, "fs") { }
+    explicit MySelector(int defaultSource) : search::FixedSourceSelector(defaultSource, "fs") { }
     MySelector & set(Source s, uint32_t docId) {
         setSource(s, docId);
         return *this;
@@ -65,12 +64,12 @@ TEST(SourceBlenderTest, test_strictness)
         a.addHit(2).addHit(5).addHit(6).addHit(8);
         b.addHit(3).addHit(5).addHit(6).addHit(7);
 
-        MySelector *sel = new MySelector(5);
+        auto *sel = new MySelector(5);
         sel->set(2, 1).set(3, 2).set(5, 2).set(7, 1);
 
-        SourceBlenderBlueprint *blend_b = new SourceBlenderBlueprint(*sel);
-        Blueprint::UP a_b(new SimpleBlueprint(a));
-        Blueprint::UP b_b(new SimpleBlueprint(b));
+        auto *blend_b = new SourceBlenderBlueprint(*sel);
+        auto a_b = std::make_unique<SimpleBlueprint>(a);
+        auto b_b = std::make_unique<SimpleBlueprint>(b);
         a_b->setSourceId(1);
         b_b->setSourceId(2);
         blend_b->addChild(std::move(a_b));
@@ -111,16 +110,16 @@ TEST(SourceBlenderTest, test_full_sourceblender_search)
     c.addHit(4).addHit(11).addHit(21).addHit(32);
 
     // these are all handed over to the blender
-    UnpackChecker *ua = new UnpackChecker(new SimpleSearch(a));
-    UnpackChecker *ub = new UnpackChecker(new SimpleSearch(b));
-    UnpackChecker *uc = new UnpackChecker(new SimpleSearch(c));
+    auto *ua = new UnpackChecker(new SimpleSearch(a));
+    auto *ub = new UnpackChecker(new SimpleSearch(b));
+    auto *uc = new UnpackChecker(new SimpleSearch(c));
     auto sel = make_unique<MySelector>(5);
 
     sel->set(2, 1).set(3, 2).set(11, 2).set(21, 3).set(34, 1);
     SourceBlenderSearch::Children abc;
-    abc.push_back(SourceBlenderSearch::Child(ua, 1));
-    abc.push_back(SourceBlenderSearch::Child(ub, 2));
-    abc.push_back(SourceBlenderSearch::Child(uc, 3));
+    abc.emplace_back(ua, 1);
+    abc.emplace_back(ub, 2);
+    abc.emplace_back(uc, 3);
 
     SearchIterator::UP blend(SourceBlenderSearch::create(sel->createIterator(), abc, true));
     SimpleResult result;
@@ -149,7 +148,7 @@ using search::test::SearchIteratorVerifier;
 class Verifier : public SearchIteratorVerifier {
 public:
     Verifier();
-    ~Verifier();
+    ~Verifier() override;
     SearchIterator::UP create(bool strict) const override {
         return SearchIterator::UP(SourceBlenderSearch::create(_selector.createIterator(),
                                                               createChildren(strict),
@@ -178,7 +177,7 @@ Verifier::Verifier() :
         _indexes[indexId].push_back(docId);
     }
 }
-Verifier::~Verifier() {}
+Verifier::~Verifier() = default;
 
 TEST(SourceBlenderTest, test_that_source_blender_iterator_adheres_to_search_terator_requirements)
 {
diff --git a/searchlib/src/tests/queryeval/sparse_vector_benchmark/sparse_vector_benchmark_test.cpp b/searchlib/src/tests/queryeval/sparse_vector_benchmark/sparse_vector_benchmark_test.cpp
index 94ecd8fa539..a7516226daf 100644
--- a/searchlib/src/tests/queryeval/sparse_vector_benchmark/sparse_vector_benchmark_test.cpp
+++ b/searchlib/src/tests/queryeval/sparse_vector_benchmark/sparse_vector_benchmark_test.cpp
@@ -13,6 +13,7 @@
 #include <vespa/searchlib/queryeval/simpleresult.h>
 #include <vespa/searchlib/queryeval/wand/weak_and_search.h>
 #include <vespa/searchlib/queryeval/weighted_set_term_search.h>
+#include <vespa/searchlib/queryeval/wand/weak_and_heap.h>
 #include <vespa/vespalib/util/box.h>
 #include <vespa/vespalib/util/stringfmt.h>
 
@@ -135,7 +136,7 @@ constexpr vespalib::duration max_time = 1000s;
 //-----------------------------------------------------------------------------
 
 struct ChildFactory {
-    ChildFactory() {}
+    ChildFactory() = default;
     virtual std::string name() const = 0;
     virtual SearchIterator::UP createChild(uint32_t idx, uint32_t limit) const = 0;
     virtual ~ChildFactory() = default;
@@ -190,8 +191,9 @@ struct ModSearchFactory : ChildFactory {
 //-----------------------------------------------------------------------------
 
 struct VespaWandFactory : SparseVectorFactory {
+    mutable SharedWeakAndPriorityQueue _scores;
     uint32_t n;
-    explicit VespaWandFactory(uint32_t n_in) noexcept : n(n_in) {}
+    explicit VespaWandFactory(uint32_t n_in) : _scores(n_in), n(n_in) {}
     std::string name() const override {
         return vespalib::make_string("VespaWand(%u)", n);
     }
@@ -200,7 +202,7 @@ struct VespaWandFactory : SparseVectorFactory {
         for (size_t i = 0; i < childCnt; ++i) {
             terms.emplace_back(childFactory.createChild(i, limit), default_weight, limit / (i + 1));
         }
-        return WeakAndSearch::create(terms, n, true);
+        return WeakAndSearch::create(terms, wand::MatchParams(_scores), n, true);
     }
 };
 
diff --git a/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp b/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
index 55dc3868ed4..457f7133dc1 100644
--- a/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
+++ b/searchlib/src/tests/queryeval/weak_and/wand_bench_setup.hpp
@@ -42,7 +42,7 @@ struct Stats {
     void unpack() noexcept {
         ++unpackCnt;
     }
-    void print() {
+    void print() const {
         fprintf(stderr, "Stats: hits=%zu, seeks=%zu, unpacks=%zu, skippedDocs=%zu, skippedHits=%zu\n",
                 hitCnt, seekCnt, unpackCnt, skippedDocs, skippedHits);
     }
@@ -100,36 +100,48 @@ struct WandFactory {
 };
 
 struct VespaWandFactory : WandFactory {
+    mutable SharedWeakAndPriorityQueue  _scores;
     uint32_t n;
-    explicit VespaWandFactory(uint32_t n_in) noexcept : n(n_in) {}
+    explicit VespaWandFactory(uint32_t n_in) noexcept
+        : _scores(n_in),
+          n(n_in)
+    {}
     ~VespaWandFactory() override;
     std::string name() const override { return make_string("VESPA WAND (n=%u)", n); }
     SearchIterator::UP create(const wand::Terms &terms) override {
-        return WeakAndSearch::create(terms, n, true);
+        return WeakAndSearch::create(terms, wand::MatchParams(_scores, 1, 1), n, true);
     }
 };
 
 VespaWandFactory::~VespaWandFactory() = default;
 
 struct VespaArrayWandFactory : WandFactory {
+    mutable SharedWeakAndPriorityQueue  _scores;
     uint32_t n;
-    explicit VespaArrayWandFactory(uint32_t n_in) noexcept : n(n_in) {}
+    explicit VespaArrayWandFactory(uint32_t n_in)
+        : _scores(n_in),
+          n(n_in)
+    {}
     ~VespaArrayWandFactory() override;
     std::string name() const override { return make_string("VESPA ARRAY WAND (n=%u)", n); }
     SearchIterator::UP create(const wand::Terms &terms) override {
-        return WeakAndSearch::createArrayWand(terms, wand::TermFrequencyScorer(), n, true);
+        return WeakAndSearch::createArrayWand(terms, wand::MatchParams(_scores, 1, 1), wand::TermFrequencyScorer(), n, true);
     }
 };
 
 VespaArrayWandFactory::~VespaArrayWandFactory() = default;
 
 struct VespaHeapWandFactory : WandFactory {
+    mutable SharedWeakAndPriorityQueue  _scores;
     uint32_t n;
-    explicit VespaHeapWandFactory(uint32_t n_in) noexcept : n(n_in) {}
+    explicit VespaHeapWandFactory(uint32_t n_in)
+        : _scores(n_in),
+          n(n_in)
+    {}
     ~VespaHeapWandFactory() override;
     std::string name() const override { return make_string("VESPA HEAP WAND (n=%u)", n); }
     SearchIterator::UP create(const wand::Terms &terms) override {
-        return WeakAndSearch::createHeapWand(terms, wand::TermFrequencyScorer(), n, true);
+        return WeakAndSearch::createHeapWand(terms, wand::MatchParams(_scores, 1, 1), wand::TermFrequencyScorer(), n, true);
     }
 };
 
@@ -151,7 +163,7 @@ struct VespaParallelWandFactory : public WandFactory {
 VespaParallelWandFactory::~VespaParallelWandFactory() = default;
 
 struct VespaParallelArrayWandFactory : public VespaParallelWandFactory {
-    VespaParallelArrayWandFactory(uint32_t n) noexcept : VespaParallelWandFactory(n) {}
+    explicit VespaParallelArrayWandFactory(uint32_t n) noexcept : VespaParallelWandFactory(n) {}
     ~VespaParallelArrayWandFactory() override;
     std::string name() const override { return make_string("VESPA ARRAY PWAND (n=%u)", scores.getScoresToTrack()); }
     SearchIterator::UP create(const wand::Terms &terms) override {
diff --git a/searchlib/src/tests/queryeval/weak_and/weak_and_test.cpp b/searchlib/src/tests/queryeval/weak_and/weak_and_test.cpp
index 689f9f085d0..4aab66f3cc9 100644
--- a/searchlib/src/tests/queryeval/weak_and/weak_and_test.cpp
+++ b/searchlib/src/tests/queryeval/weak_and/weak_and_test.cpp
@@ -1,8 +1,7 @@
 // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/searchlib/queryeval/fake_search.h>
 #include <vespa/searchlib/queryeval/wand/weak_and_search.h>
+#include <vespa/searchlib/queryeval/wand/weak_and_heap.h>
 #include <vespa/searchlib/queryeval/simpleresult.h>
-#include <vespa/searchlib/queryeval/simplesearch.h>
 #include <vespa/searchlib/queryeval/test/eagerchild.h>
 #include <vespa/searchlib/queryeval/test/leafspec.h>
 #include <vespa/searchlib/queryeval/test/wandspec.h>
@@ -20,11 +19,13 @@ namespace {
 
 struct MyWandSpec : public WandSpec
 {
+    SharedWeakAndPriorityQueue scores;
     uint32_t n;
 
-    MyWandSpec(uint32_t n_) : WandSpec(), n(n_) {}
+    explicit MyWandSpec(uint32_t n_in) : WandSpec(), scores(n_in), n(n_in) {}
     SearchIterator *create() {
-        return new TrackedSearch("WAND", getHistory(), WeakAndSearch::create(getTerms(), n, true));
+        return new TrackedSearch("WAND", getHistory(),
+                                 WeakAndSearch::create(getTerms(), wand::MatchParams(scores, 1, 1), n, true));
     }
 };
 
@@ -104,7 +105,8 @@ TEST(WeakAndTest, require_that_initial_docid_for_subsearches_are_taken_into_acco
     wand::Terms terms;
     terms.push_back(wand::Term(new TrackedSearch("foo", history, new EagerChild(search::endDocId)), 100, 1));
     terms.push_back(wand::Term(new TrackedSearch("bar", history, new EagerChild(10)), 100, 2));
-    SearchIterator::UP search(new TrackedSearch("WAND", history, WeakAndSearch::create(terms, 2, true)));
+    SharedWeakAndPriorityQueue scores(2);
+    auto search = std::make_unique<TrackedSearch>("WAND", history, WeakAndSearch::create(terms, wand::MatchParams(scores), 2, true));
     SimpleResult hits;
     hits.search(*search);
     EXPECT_EQ(SimpleResult().addHit(10), hits);
@@ -114,17 +116,26 @@ TEST(WeakAndTest, require_that_initial_docid_for_subsearches_are_taken_into_acco
 }
 
 class IteratorChildrenVerifier : public search::test::IteratorChildrenVerifier {
+public:
+    IteratorChildrenVerifier();
+    ~IteratorChildrenVerifier() override;
 private:
+    mutable std::vector<std::unique_ptr<SharedWeakAndPriorityQueue>> _scores;
     SearchIterator::UP create(bool strict) const override {
         wand::Terms terms;
         for (size_t i = 0; i < _num_children; ++i) {
             terms.emplace_back(createIterator(_split_lists[i], strict).release(),
                                100, _split_lists[i].size());
         }
-        return SearchIterator::UP(WeakAndSearch::create(terms, -1, strict));
+        static constexpr size_t LARGE_ENOUGH_HEAP_FOR_ALL = 10000;
+        _scores.push_back(std::make_unique<SharedWeakAndPriorityQueue>(LARGE_ENOUGH_HEAP_FOR_ALL));
+        return WeakAndSearch::create(terms, wand::MatchParams(*_scores.back(), 1, 1), -1, strict);
     }
 };
 
+IteratorChildrenVerifier::IteratorChildrenVerifier() : _scores() {}
+IteratorChildrenVerifier::~IteratorChildrenVerifier() = default;
+
 TEST(WeakAndTest, verify_search_iterator_conformance)
 {
     IteratorChildrenVerifier verifier;
diff --git a/searchlib/src/tests/queryeval/weak_and/weak_and_test_expensive.cpp b/searchlib/src/tests/queryeval/weak_and/weak_and_test_expensive.cpp
index 54bf1e92037..0573404a3b4 100644
--- a/searchlib/src/tests/queryeval/weak_and/weak_and_test_expensive.cpp
+++ b/searchlib/src/tests/queryeval/weak_and/weak_and_test_expensive.cpp
@@ -16,15 +16,16 @@ void checkWandHits(WandFactory &vespa, WandFactory &rise, uint32_t step, uint32_
     s1->initFullRange();
     SearchIterator::UP s2 = riseSetup.create();
     s2->initFullRange();
-    ASSERT_TRUE(dynamic_cast<WeakAndType*>(s1.get()) != 0);
-    ASSERT_TRUE(dynamic_cast<WeakAndType*>(s2.get()) == 0);
-    ASSERT_TRUE(dynamic_cast<RiseType*>(s2.get()) != 0);
-    ASSERT_TRUE(dynamic_cast<RiseType*>(s1.get()) == 0);
+    ASSERT_TRUE(dynamic_cast<WeakAndType*>(s1.get()) != nullptr);
+    ASSERT_TRUE(dynamic_cast<WeakAndType*>(s2.get()) == nullptr);
+    ASSERT_TRUE(dynamic_cast<RiseType*>(s2.get()) != nullptr);
+    ASSERT_TRUE(dynamic_cast<RiseType*>(s1.get()) == nullptr);
     s1->seek(1);
     s2->seek(1);
     while (!s1->isAtEnd() &&
            !s2->isAtEnd())
     {
+        if (s1->getDocId() != s2->getDocId()) assert(true);
         ASSERT_EQUAL(s1->getDocId(), s2->getDocId());
         if ((filter == 0) || ((s1->getDocId() % filter) != 0)) {
             s1->unpack(s1->getDocId());
diff --git a/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp b/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp
index 20300999192..14d21b1294b 100644
--- a/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp
@@ -458,7 +458,7 @@ public:
           _scores(scoresToTrack),
           _scoreThreshold(scoreThreshold),
           _thresholdBoostFactor(thresholdBoostFactor),
-          _scoresAdjustFrequency(queryeval::DEFAULT_PARALLEL_WAND_SCORES_ADJUST_FREQUENCY),
+          _scoresAdjustFrequency(queryeval::wand::DEFAULT_PARALLEL_WAND_SCORES_ADJUST_FREQUENCY),
           _weights(),
           _terms(),
           _attr(attr),
diff --git a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
index 532b9b7cede..e575b7a8236 100644
--- a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
@@ -419,6 +419,13 @@ WeakAndBlueprint::my_flow(InFlow in_flow) const
     return AnyFlow::create<OrFlow>(in_flow);
 }
 
+WeakAndBlueprint::WeakAndBlueprint(uint32_t n, float idf_range)
+    : _scores(n),
+      _n(n),
+      _idf_range(idf_range),
+      _weights()
+{}
+
 WeakAndBlueprint::~WeakAndBlueprint() = default;
 
 FlowStats
@@ -478,13 +485,12 @@ WeakAndBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
     assert(_weights.size() == childCnt());
     for (size_t i = 0; i < sub_searches.size(); ++i) {
         // TODO: pass ownership with unique_ptr
-        terms.emplace_back(sub_searches[i].release(),
-                           _weights[i],
+        terms.emplace_back(sub_searches[i].release(), _weights[i],
                            getChild(i).getState().estimate().estHits);
     }
     return (_idf_range == 0.0)
-        ? WeakAndSearch::create(terms, wand::TermFrequencyScorer(), _n, strict())
-        : WeakAndSearch::create(terms, wand::Bm25TermFrequencyScorer(get_docid_limit(), _idf_range), _n, strict());
+        ? WeakAndSearch::create(terms, wand::MatchParams(_scores), wand::TermFrequencyScorer(), _n, strict())
+        : WeakAndSearch::create(terms, wand::MatchParams(_scores), wand::Bm25TermFrequencyScorer(get_docid_limit(), _idf_range), _n, strict());
 }
 
 SearchIterator::UP
@@ -549,7 +555,7 @@ NearBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
             tfmda.add(cs.field(j).resolve(md));
         }
     }
-    return SearchIterator::UP(new NearSearch(std::move(sub_searches), tfmda, _window, strict()));
+    return std::make_unique<NearSearch>(std::move(sub_searches), tfmda, _window, strict());
 }
 
 SearchIterator::UP
@@ -612,7 +618,7 @@ ONearBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
     }
     // could sort sub_searches here
     // but then strictness inheritance would also need to be fixed
-    return SearchIterator::UP(new ONearSearch(std::move(sub_searches), tfmda, _window, strict()));
+    return std::make_unique<ONearSearch>(std::move(sub_searches), tfmda, _window, strict());
 }
 
 SearchIterator::UP
diff --git a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
index 913370caae1..2b1e7f27a51 100644
--- a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
+++ b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
@@ -4,6 +4,7 @@
 
 #include "blueprint.h"
 #include "multisearch.h"
+#include <vespa/searchlib/queryeval/wand/weak_and_heap.h>
 
 namespace search::queryeval {
 
@@ -88,6 +89,7 @@ private:
 class WeakAndBlueprint : public IntermediateBlueprint
 {
 private:
+    mutable SharedWeakAndPriorityQueue  _scores;
     uint32_t              _n;
     float                 _idf_range;
     std::vector<uint32_t> _weights;
@@ -106,15 +108,15 @@ public:
                              fef::MatchData &md) const override;
     SearchIterator::UP createFilterSearch(FilterConstraint constraint) const override;
 
-    explicit WeakAndBlueprint(uint32_t n) noexcept : WeakAndBlueprint(n, 0.0) {}
-    WeakAndBlueprint(uint32_t n, float idf_range) noexcept : _n(n), _idf_range(idf_range), _weights() {}
+    explicit WeakAndBlueprint(uint32_t n) : WeakAndBlueprint(n, 0.0) {}
+    WeakAndBlueprint(uint32_t n, float idf_range);
     ~WeakAndBlueprint() override;
     void addTerm(Blueprint::UP bp, uint32_t weight) {
         addChild(std::move(bp));
         _weights.push_back(weight);
     }
-    uint32_t getN() const { return _n; }
-    const std::vector<uint32_t> &getWeights() const { return _weights; }
+    uint32_t getN() const noexcept { return _n; }
+    const std::vector<uint32_t> &getWeights() const noexcept { return _weights; }
 };
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_blueprint.cpp b/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_blueprint.cpp
index 2a200acbd94..105115445f7 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_blueprint.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_blueprint.cpp
@@ -18,23 +18,7 @@ ParallelWeakAndBlueprint::ParallelWeakAndBlueprint(FieldSpecBase field,
       _scores(scoresToTrack),
       _scoreThreshold(scoreThreshold),
       _thresholdBoostFactor(thresholdBoostFactor),
-      _scoresAdjustFrequency(DEFAULT_PARALLEL_WAND_SCORES_ADJUST_FREQUENCY),
-      _layout(),
-      _weights(),
-      _terms()
-{
-}
-
-ParallelWeakAndBlueprint::ParallelWeakAndBlueprint(FieldSpecBase field,
-                                                   uint32_t scoresToTrack,
-                                                   score_t scoreThreshold,
-                                                   double thresholdBoostFactor,
-                                                   uint32_t scoresAdjustFrequency)
-    : ComplexLeafBlueprint(field),
-      _scores(scoresToTrack),
-      _scoreThreshold(scoreThreshold),
-      _thresholdBoostFactor(thresholdBoostFactor),
-      _scoresAdjustFrequency(scoresAdjustFrequency),
+      _scoresAdjustFrequency(wand::DEFAULT_PARALLEL_WAND_SCORES_ADJUST_FREQUENCY),
       _layout(),
       _weights(),
       _terms()
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_blueprint.h b/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_blueprint.h
index 4a55bf14095..cc67303e90a 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_blueprint.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_blueprint.h
@@ -11,8 +11,6 @@
 
 namespace search::queryeval {
 
-const uint32_t DEFAULT_PARALLEL_WAND_SCORES_ADJUST_FREQUENCY = 4;
-
 /**
  * Blueprint for the parallel weak and search operator.
  */
@@ -36,17 +34,10 @@ public:
                              uint32_t scoresToTrack,
                              score_t scoreThreshold,
                              double thresholdBoostFactor);
-    ParallelWeakAndBlueprint(FieldSpecBase field,
-                             uint32_t scoresToTrack,
-                             score_t scoreThreshold,
-                             double thresholdBoostFactor,
-                             uint32_t scoresAdjustFrequency);
     ~ParallelWeakAndBlueprint() override;
 
     const WeakAndHeap &getScores() const { return _scores; }
-
     score_t getScoreThreshold() const { return _scoreThreshold; }
-
     double getThresholdBoostFactor() const { return _thresholdBoostFactor; }
 
     // Used by create visitor
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h b/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
index 4ac1bf3d89b..9496090cca3 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
@@ -23,6 +23,8 @@ using score_t = int64_t;
 using docid_t = uint32_t;
 using ref_t = uint16_t;
 
+const uint32_t DEFAULT_PARALLEL_WAND_SCORES_ADJUST_FREQUENCY = 4;
+
 //-----------------------------------------------------------------------------
 
 /**
@@ -33,6 +35,9 @@ struct MatchParams
     WeakAndHeap   &scores;
     score_t        scoreThreshold;
     const uint32_t scoresAdjustFrequency;
+    MatchParams(WeakAndHeap &scores_in) noexcept
+        : MatchParams(scores_in, 1, DEFAULT_PARALLEL_WAND_SCORES_ADJUST_FREQUENCY)
+    {}
     MatchParams(WeakAndHeap &scores_in, score_t scoreThreshold_in, uint32_t scoresAdjustFrequency_in) noexcept
         : scores(scores_in),
           scoreThreshold(scoreThreshold_in),
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_heap.cpp b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_heap.cpp
index d4b92fd67e6..03fc7ec0c36 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_heap.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_heap.cpp
@@ -8,9 +8,7 @@ SharedWeakAndPriorityQueue::SharedWeakAndPriorityQueue(uint32_t scoresToTrack) :
     WeakAndHeap(scoresToTrack),
     _bestScores(),
     _lock()
-{
-    _bestScores.reserve(scoresToTrack);
-}
+{ }
 
 SharedWeakAndPriorityQueue::~SharedWeakAndPriorityQueue() = default;
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
index cf3fd44ad4f..588f9e827fd 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
@@ -21,6 +21,7 @@ private:
     Algorithm                      _algo;
     score_t                        _threshold; // current score threshold
     Scores                         _scores;    // best n scores
+    MatchParams                    _matchParams;
     const uint32_t                 _n;
 
     void seek_strict(uint32_t docid) {
@@ -43,12 +44,13 @@ private:
 
 public:
     template<typename Scorer>
-    WeakAndSearchLR(const Terms &terms, const Scorer & scorer, uint32_t n)
+    WeakAndSearchLR(const Terms &terms, const MatchParams & matchParams, const Scorer & scorer, uint32_t n)
         : _terms(terms, scorer, 0, {}),
           _heaps(DocIdOrder(_terms.docId()), _terms.size()),
           _algo(),
-          _threshold(1),
+          _threshold(matchParams.scoreThreshold),
           _scores(),
+          _matchParams(matchParams),
           _n(n)
     {
     }
@@ -105,48 +107,49 @@ WeakAndSearch::visitMembers(vespalib::ObjectVisitor &visitor) const
 
 template<typename Scorer>
 SearchIterator::UP
-WeakAndSearch::createArrayWand(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict)
+WeakAndSearch::createArrayWand(const Terms &terms, const MatchParams & params,
+                               const Scorer & scorer, uint32_t n, bool strict)
 {
     if (strict) {
-        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>>(terms, scorer, n);
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>>(terms, params, scorer, n);
     } else {
-        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>>(terms, scorer, n);
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>>(terms, params, scorer, n);
     }
 }
 
 template<typename Scorer>
 SearchIterator::UP
-WeakAndSearch::createHeapWand(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict)
+WeakAndSearch::createHeapWand(const Terms &terms, const MatchParams & params, const Scorer & scorer, uint32_t n, bool strict)
 {
     if (strict) {
-        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, true>>(terms, scorer, n);
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, true>>(terms, params, scorer, n);
     } else {
-        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, false>>(terms, scorer, n);
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, false>>(terms, params, scorer, n);
     }
 }
 
 template<typename Scorer>
 SearchIterator::UP
-WeakAndSearch::create(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict)
+WeakAndSearch::create(const Terms &terms, const MatchParams & params, const Scorer & scorer, uint32_t n, bool strict)
 {
     if (terms.size() < 128) {
-        return createArrayWand(terms, scorer, n, strict);
+        return createArrayWand(terms, params, scorer, n, strict);
     } else {
-        return createHeapWand(terms, scorer, n, strict);
+        return createHeapWand(terms, params, scorer, n, strict);
     }
 }
 
 SearchIterator::UP
-WeakAndSearch::create(const Terms &terms, uint32_t n, bool strict)
+WeakAndSearch::create(const Terms &terms, const MatchParams & params, uint32_t n, bool strict)
 {
-    return create(terms, wand::TermFrequencyScorer(), n, strict);
+    return create(terms, params, wand::TermFrequencyScorer(), n, strict);
 }
 
 //-----------------------------------------------------------------------------
 
-template SearchIterator::UP WeakAndSearch::create<wand::TermFrequencyScorer>(const Terms &terms, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
-template SearchIterator::UP WeakAndSearch::create<wand::Bm25TermFrequencyScorer>(const Terms &terms, const wand::Bm25TermFrequencyScorer & scorer, uint32_t n, bool strict);
-template SearchIterator::UP WeakAndSearch::createArrayWand<wand::TermFrequencyScorer>(const Terms &terms, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
-template SearchIterator::UP WeakAndSearch::createHeapWand<wand::TermFrequencyScorer>(const Terms &terms, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
+template SearchIterator::UP WeakAndSearch::create<wand::TermFrequencyScorer>(const Terms &terms, const MatchParams & params, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
+template SearchIterator::UP WeakAndSearch::create<wand::Bm25TermFrequencyScorer>(const Terms &terms, const MatchParams & params, const wand::Bm25TermFrequencyScorer & scorer, uint32_t n, bool strict);
+template SearchIterator::UP WeakAndSearch::createArrayWand<wand::TermFrequencyScorer>(const Terms &terms, const MatchParams & params, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
+template SearchIterator::UP WeakAndSearch::createHeapWand<wand::TermFrequencyScorer>(const Terms &terms, const MatchParams & params, const wand::TermFrequencyScorer & scorer, uint32_t n, bool strict);
 
 }
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
index a91b2860a63..30292af24ab 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
@@ -9,6 +9,7 @@ namespace search::queryeval {
 
 struct WeakAndSearch : SearchIterator {
     using Terms = wand::Terms;
+    using MatchParams = wand::MatchParams;
     virtual size_t get_num_terms() const = 0;
     virtual int32_t get_term_weight(size_t idx) const = 0;
     virtual wand::score_t get_max_score(size_t idx) const = 0;
@@ -16,12 +17,16 @@ struct WeakAndSearch : SearchIterator {
     virtual uint32_t getN() const = 0;
     void visitMembers(vespalib::ObjectVisitor &visitor) const override;
     template<typename Scorer>
-    static SearchIterator::UP createArrayWand(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict);
+    static SearchIterator::UP createArrayWand(const Terms &terms, const MatchParams & matchParams,
+                                              const Scorer & scorer, uint32_t n, bool strict);
     template<typename Scorer>
-    static SearchIterator::UP createHeapWand(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict);
+    static SearchIterator::UP createHeapWand(const Terms &terms, const MatchParams & matchParams,
+                                             const Scorer & scorer, uint32_t n, bool strict);
     template<typename Scorer>
-    static SearchIterator::UP create(const Terms &terms, const Scorer & scorer, uint32_t n, bool strict);
-    static SearchIterator::UP create(const Terms &terms, uint32_t n, bool strict);
+    static SearchIterator::UP create(const Terms &terms, const MatchParams & matchParams,
+                                     const Scorer & scorer, uint32_t n, bool strict);
+    static SearchIterator::UP create(const Terms &terms, const MatchParams & matchParams,
+                                     uint32_t n, bool strict);
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/test/CMakeLists.txt b/searchlib/src/vespa/searchlib/test/CMakeLists.txt
index 83e185dbfb6..4685ad07808 100644
--- a/searchlib/src/vespa/searchlib/test/CMakeLists.txt
+++ b/searchlib/src/vespa/searchlib/test/CMakeLists.txt
@@ -14,6 +14,7 @@ vespa_add_library(searchlib_test
     schema_builder.cpp
     string_field_builder.cpp
     vector_buffer_writer.cpp
+    weightedchildrenverifiers.cpp
     $<TARGET_OBJECTS:searchlib_test_fakedata>
     $<TARGET_OBJECTS:searchlib_searchlib_test_diskindex>
     $<TARGET_OBJECTS:searchlib_test_gtest_migration>
diff --git a/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.cpp b/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.cpp
new file mode 100644
index 00000000000..b22dd1a3aa9
--- /dev/null
+++ b/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.cpp
@@ -0,0 +1,71 @@
+// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include "weightedchildrenverifiers.h"
+
+using search::queryeval::SearchIterator;
+
+namespace search::test {
+
+WeightedChildrenVerifier::WeightedChildrenVerifier()
+    : _weights(_num_children, 1)
+{ }
+WeightedChildrenVerifier::~WeightedChildrenVerifier() = default;
+
+
+IteratorChildrenVerifier::IteratorChildrenVerifier()
+    : WeightedChildrenVerifier(),
+      _split_lists(_num_children)
+{
+    auto full_list = getExpectedDocIds();
+    for (size_t i = 0; i < full_list.size(); ++i) {
+        _split_lists[i % _num_children].push_back(full_list[i]);
+    }
+}
+IteratorChildrenVerifier::~IteratorChildrenVerifier() = default;
+
+SearchIterator::UP
+IteratorChildrenVerifier::create(bool strict) const {
+    (void) strict;
+    std::vector<SearchIterator*> children;
+    for (size_t i = 0; i < _num_children; ++i) {
+        children.push_back(createIterator(_split_lists[i], true).release());
+    }
+    return create(children);
+}
+
+SearchIterator::UP
+IteratorChildrenVerifier::create(const std::vector<SearchIterator*> &children) const {
+    (void) children;
+    return {};
+}
+
+
+DwwIteratorChildrenVerifier::DwwIteratorChildrenVerifier()
+    : WeightedChildrenVerifier(),
+      _helper()
+{
+    _helper.add_docs(getDocIdLimit());
+    auto full_list = getExpectedDocIds();
+    for (size_t i = 0; i < full_list.size(); ++i) {
+        _helper.set_doc(full_list[i], i % _num_children, 1);
+    }
+}
+DwwIteratorChildrenVerifier::~DwwIteratorChildrenVerifier() = default;
+
+SearchIterator::UP
+DwwIteratorChildrenVerifier::create(bool strict) const {
+    (void) strict;
+    std::vector<DocidWithWeightIterator> children;
+    for (size_t i = 0; i < _num_children; ++i) {
+        auto dict_entry = _helper.dww().lookup(vespalib::make_string("%zu", i).c_str(), _helper.dww().get_dictionary_snapshot());
+        _helper.dww().create(dict_entry.posting_idx, children);
+    }
+    return create(std::move(children));
+}
+SearchIterator::UP
+DwwIteratorChildrenVerifier::create(std::vector<DocidWithWeightIterator> &&) const  {
+    return {};
+}
+
+
+}
diff --git a/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.h b/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.h
index 86d2fb9aa67..037d1086950 100644
--- a/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.h
+++ b/searchlib/src/vespa/searchlib/test/weightedchildrenverifiers.h
@@ -8,11 +8,8 @@ namespace search::test {
 
 class WeightedChildrenVerifier : public SearchIteratorVerifier {
 public:
-    WeightedChildrenVerifier()
-        : _weights(_num_children, 1)
-    { }
-    ~WeightedChildrenVerifier() override {}
-
+    WeightedChildrenVerifier();
+    ~WeightedChildrenVerifier() override;
 protected:
     static constexpr size_t _num_children = 7;
     mutable fef::TermFieldMatchData _tfmd;
@@ -21,58 +18,21 @@ protected:
 
 class IteratorChildrenVerifier : public WeightedChildrenVerifier {
 public:
-    IteratorChildrenVerifier()
-        : WeightedChildrenVerifier(),
-          _split_lists(_num_children)
-    {
-        auto full_list = getExpectedDocIds();
-        for (size_t i = 0; i < full_list.size(); ++i) {
-            _split_lists[i % _num_children].push_back(full_list[i]);
-        }
-    }
-    ~IteratorChildrenVerifier() override { }
-    SearchIterator::UP create(bool strict) const override {
-        (void) strict;
-        std::vector<SearchIterator*> children;
-        for (size_t i = 0; i < _num_children; ++i) {
-            children.push_back(createIterator(_split_lists[i], true).release());
-        }
-        return create(children);
-    }
+    IteratorChildrenVerifier();
+    ~IteratorChildrenVerifier() override;
+    SearchIterator::UP create(bool strict) const override;
 protected:
-    virtual SearchIterator::UP create(const std::vector<SearchIterator*> &children) const {
-        (void) children;
-        return SearchIterator::UP();
-    }
+    virtual SearchIterator::UP create(const std::vector<SearchIterator*> &children) const;
     std::vector<DocIds> _split_lists;
 };
 
 class DwwIteratorChildrenVerifier : public WeightedChildrenVerifier {
 public:
-    DwwIteratorChildrenVerifier() :
-        WeightedChildrenVerifier(),
-        _helper()
-    {
-        _helper.add_docs(getDocIdLimit());
-        auto full_list = getExpectedDocIds();
-        for (size_t i = 0; i < full_list.size(); ++i) {
-            _helper.set_doc(full_list[i], i % _num_children, 1);
-        }
-    }
-    ~DwwIteratorChildrenVerifier() override {}
-    SearchIterator::UP create(bool strict) const override {
-        (void) strict;
-        std::vector<DocidWithWeightIterator> children;
-        for (size_t i = 0; i < _num_children; ++i) {
-            auto dict_entry = _helper.dww().lookup(vespalib::make_string("%zu", i).c_str(), _helper.dww().get_dictionary_snapshot());
-            _helper.dww().create(dict_entry.posting_idx, children);
-        }
-        return create(std::move(children));
-    }
+    DwwIteratorChildrenVerifier();
+    ~DwwIteratorChildrenVerifier() override;
+    SearchIterator::UP create(bool strict) const override;
 protected:
-    virtual SearchIterator::UP create(std::vector<DocidWithWeightIterator> &&) const  {
-        return {};
-    }
+    virtual SearchIterator::UP create(std::vector<DocidWithWeightIterator> &&) const;
     DocumentWeightAttributeHelper _helper;
 };