Separate the weighted/non-weighted solution.

1 files changed, 86 insertions, 27 deletions

diff --git a/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp b/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
index c11d2d65361..d9e904aafdb 100644
--- a/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
@@ -77,30 +77,40 @@ struct WeightedRef {
     }
 };
 
-struct TargetResult {
+struct TargetWeightedResult {
     std::vector<WeightedRef> weightedRefs;
     size_t sizeSum;
 
-    TargetResult()
+    TargetWeightedResult()
         : weightedRefs(),
           sizeSum(0)
     {
     }
+    static TargetWeightedResult
+    getResult(ReverseMappingRefs reverseMappingRefs, const ReverseMapping &reverseMapping,
+              SearchContext &target_search_context, uint32_t committedDocIdLimit) __attribute__((noinline));
 };
 
-TargetResult
-getTargetResult(ReverseMappingRefs reverseMappingRefs,
-                const ReverseMapping &reverseMapping,
-                SearchContext &target_search_context,
-                uint32_t committedDocIdLimit) __attribute__((noinline));
+struct TargetResult {
+    std::vector<EntryRef> refs;
+    size_t sizeSum;
 
-TargetResult
-getTargetResult(ReverseMappingRefs reverseMappingRefs,
-                const ReverseMapping &reverseMapping,
-                SearchContext &target_search_context,
-                uint32_t committedDocIdLimit)
+    TargetResult()
+        : refs(),
+          sizeSum(0)
+    {
+    }
+
+    static TargetResult
+    getResult(ReverseMappingRefs reverseMappingRefs, const ReverseMapping &reverseMapping,
+              SearchContext &target_search_context, uint32_t committedDocIdLimit) __attribute__((noinline));
+};
+
+TargetWeightedResult
+TargetWeightedResult::getResult(ReverseMappingRefs reverseMappingRefs, const ReverseMapping &reverseMapping,
+                                SearchContext &target_search_context, uint32_t committedDocIdLimit)
 {
-    TargetResult targetResult;
+    TargetWeightedResult targetResult;
     fef::TermFieldMatchData matchData;
     auto targetItr = target_search_context.createIterator(&matchData, true);
     uint32_t docIdLimit = reverseMappingRefs.size();
@@ -131,6 +141,39 @@ getTargetResult(ReverseMappingRefs reverseMappingRefs,
     return targetResult;
 }
 
+TargetResult
+TargetResult::getResult(ReverseMappingRefs reverseMappingRefs, const ReverseMapping &reverseMapping,
+                        SearchContext &target_search_context, uint32_t committedDocIdLimit)
+{
+    TargetResult targetResult;
+    fef::TermFieldMatchData matchData;
+    auto targetItr = target_search_context.createIterator(&matchData, true);
+    uint32_t docIdLimit = reverseMappingRefs.size();
+    if (docIdLimit > committedDocIdLimit) {
+        docIdLimit = committedDocIdLimit;
+    }
+    uint32_t lid = 1;
+    targetItr->initRange(1, docIdLimit);
+    while (lid < docIdLimit) {
+        if (targetItr->seek(lid)) {
+            EntryRef revMapIdx = reverseMappingRefs[lid];
+            if (revMapIdx.valid()) {
+                uint32_t size = reverseMapping.frozenSize(revMapIdx);
+                targetResult.sizeSum += size;
+                targetResult.refs.emplace_back(revMapIdx);
+            }
+            ++lid;
+        } else {
+            ++lid;
+            uint32_t nextLid = targetItr->getDocId();
+            if (nextLid > lid) {
+                lid = nextLid;
+            }
+        }
+    }
+    return targetResult;
+}
+
 class ReverseMappingPostingList
 {
     const ReverseMapping &_reverseMapping;
@@ -141,14 +184,27 @@ public:
         : _reverseMapping(reverseMapping),
           _revMapIdx(revMapIdx),
           _weight(weight)
-    {
-    }
+    {}
     ~ReverseMappingPostingList() { }
     template <typename Func>
     void foreach(Func func) const {
         int32_t weight = _weight;
         _reverseMapping.foreach_frozen_key(_revMapIdx, [func, weight](uint32_t lid) { func(lid, weight); });
     }
+
+};
+
+class ReverseMappingBitVector
+{
+    const ReverseMapping &_reverseMapping;
+    EntryRef _revMapIdx;
+public:
+    ReverseMappingBitVector(const ReverseMapping &reverseMapping, EntryRef revMapIdx)
+        : _reverseMapping(reverseMapping),
+          _revMapIdx(revMapIdx)
+    {}
+    ~ReverseMappingBitVector() { }
+
     template <typename Func>
     void foreach_key(Func func) const {
         _reverseMapping.foreach_frozen_key(_revMapIdx, [func](uint32_t lid) { func(lid); });
@@ -161,21 +217,24 @@ void ImportedSearchContext::makeMergedPostings(bool isFilter)
 {
     uint32_t committedTargetDocIdLimit = _target_attribute.getCommittedDocIdLimit();
     std::atomic_thread_fence(std::memory_order_acquire);
-    TargetResult targetResult(getTargetResult(_reference_attribute.getReverseMappingRefs(),
-                                              _reference_attribute.getReverseMapping(),
-                                              *_target_search_context,
-                                              committedTargetDocIdLimit));
-    _merger.reserveArray(targetResult.weightedRefs.size(), targetResult.sizeSum);
     const auto &reverseMapping = _reference_attribute.getReverseMapping();
     if (isFilter) {
+        TargetResult targetResult(TargetResult::getResult(_reference_attribute.getReverseMappingRefs(),
+                                                          _reference_attribute.getReverseMapping(),
+                                                          *_target_search_context,
+                                                          committedTargetDocIdLimit));
         _merger.allocBitVector();
-    }
-    for (const auto &weightedRef : targetResult.weightedRefs) {
-        ReverseMappingPostingList rmp(reverseMapping, weightedRef.revMapIdx, weightedRef.weight);
-        if (isFilter) {
-            _merger.addToBitVector(rmp);
-        } else {
-            _merger.addToArray(rmp);
+        for (EntryRef ref : targetResult.refs) {
+            _merger.addToBitVector(ReverseMappingBitVector(reverseMapping, ref));
+        }
+    } else {
+        TargetWeightedResult targetResult(TargetWeightedResult::getResult(_reference_attribute.getReverseMappingRefs(),
+                                                                          _reference_attribute.getReverseMapping(),
+                                                                          *_target_search_context,
+                                                                          committedTargetDocIdLimit));
+        _merger.reserveArray(targetResult.weightedRefs.size(), targetResult.sizeSum);
+        for (const auto &weightedRef : targetResult.weightedRefs) {
+            _merger.addToArray(ReverseMappingPostingList(reverseMapping, weightedRef.revMapIdx, weightedRef.weight));
         }
     }
     _merger.merge();