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

- Wire in a common shared heap for WeakAnd.

8 files changed, 96 insertions, 81 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());