Apache Lucene open-source search software
Speed up advancing on the disjunction iterator. (#14052)
Adrien Grandbc341f2b3e67
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex 963f8861212..2ec55fd296a 100644--- a/lucene/CHANGES.txt+++ b/lucene/CHANGES.txt@@ -47,7 +47,8 @@ ImprovementsOptimizations----------------------(No changes)++* GITHUB#14052: Speed up DisjunctionDISIApproximation#advance. (Adrien Grand)Bug Fixes---------------------diff --git a/lucene/core/src/java/org/apache/lucene/search/AbstractMultiTermQueryConstantScoreWrapper.java b/lucene/core/src/java/org/apache/lucene/search/AbstractMultiTermQueryConstantScoreWrapper.javaindex fc18b0476a7..b6ee4db540a 100644--- a/lucene/core/src/java/org/apache/lucene/search/AbstractMultiTermQueryConstantScoreWrapper.java+++ b/lucene/core/src/java/org/apache/lucene/search/AbstractMultiTermQueryConstantScoreWrapper.java@@ -28,7 +28,6 @@ import org.apache.lucene.index.Terms;import org.apache.lucene.index.TermsEnum;import org.apache.lucene.util.Accountable;import org.apache.lucene.util.BytesRef;-import org.apache.lucene.util.IOSupplier;import org.apache.lucene.util.RamUsageEstimator;/**@@ -151,7 +150,8 @@ abstract class AbstractMultiTermQueryConstantScoreWrapper<Q extends MultiTermQueint fieldDocCount,Terms terms,TermsEnum termsEnum,- List<TermAndState> collectedTerms)+ List<TermAndState> collectedTerms,+ long leadCost)throws IOException;private WeightOrDocIdSetIterator rewriteAsBooleanQuery(@@ -247,21 +247,22 @@ abstract class AbstractMultiTermQueryConstantScoreWrapper<Q extends MultiTermQuecost = estimateCost(terms, q.getTermsCount());}- IOSupplier<WeightOrDocIdSetIterator> weightOrIteratorSupplier =- () -> {+ IOLongFunction<WeightOrDocIdSetIterator> weightOrIteratorSupplier =+ leadCost -> {if (collectResult) {return rewriteAsBooleanQuery(context, collectedTerms);} else {// Too many terms to rewrite as a simple bq.// Invoke rewriteInner logic to handle rewriting:- return rewriteInner(context, fieldDocCount, terms, termsEnum, collectedTerms);+ return rewriteInner(+ context, fieldDocCount, terms, termsEnum, collectedTerms, leadCost);}};return new ScorerSupplier() {@Overridepublic Scorer get(long leadCost) throws IOException {- WeightOrDocIdSetIterator weightOrIterator = weightOrIteratorSupplier.get();+ WeightOrDocIdSetIterator weightOrIterator = weightOrIteratorSupplier.apply(leadCost);final Scorer scorer;if (weightOrIterator == null) {scorer = null;@@ -281,7 +282,8 @@ abstract class AbstractMultiTermQueryConstantScoreWrapper<Q extends MultiTermQue@Overridepublic BulkScorer bulkScorer() throws IOException {- WeightOrDocIdSetIterator weightOrIterator = weightOrIteratorSupplier.get();+ WeightOrDocIdSetIterator weightOrIterator =+ weightOrIteratorSupplier.apply(Long.MAX_VALUE);final BulkScorer bulkScorer;if (weightOrIterator == null) {bulkScorer = null;@@ -311,6 +313,10 @@ abstract class AbstractMultiTermQueryConstantScoreWrapper<Q extends MultiTermQue};}+ private static interface IOLongFunction<T> {+ T apply(long arg) throws IOException;+ }+private static long estimateCost(Terms terms, long queryTermsCount) throws IOException {// Estimate the cost. If the MTQ can provide its term count, we can do a better job// estimating.diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.java b/lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.javaindex 7732445e8cd..b7c613d06a7 100644--- a/lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.java+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.java@@ -237,7 +237,8 @@ final class BooleanScorerSupplier extends ScorerSupplier {Scorer prohibitedScorer =prohibited.size() == 1? prohibited.get(0)- : new DisjunctionSumScorer(prohibited, ScoreMode.COMPLETE_NO_SCORES);+ : new DisjunctionSumScorer(+ prohibited, ScoreMode.COMPLETE_NO_SCORES, positiveScorerCost);return new ReqExclBulkScorer(positiveScorer, prohibitedScorer);}}@@ -509,7 +510,7 @@ final class BooleanScorerSupplier extends ScorerSupplier {if ((scoreMode == ScoreMode.TOP_SCORES && topLevelScoringClause) || minShouldMatch > 1) {return new WANDScorer(optionalScorers, minShouldMatch, scoreMode, leadCost);} else {- return new DisjunctionSumScorer(optionalScorers, scoreMode);+ return new DisjunctionSumScorer(optionalScorers, scoreMode, leadCost);}}}diff --git a/lucene/core/src/java/org/apache/lucene/search/DisjunctionDISIApproximation.java b/lucene/core/src/java/org/apache/lucene/search/DisjunctionDISIApproximation.javaindex 805eadff25a..3b7e2b1014c 100644--- a/lucene/core/src/java/org/apache/lucene/search/DisjunctionDISIApproximation.java+++ b/lucene/core/src/java/org/apache/lucene/search/DisjunctionDISIApproximation.java@@ -17,6 +17,10 @@package org.apache.lucene.search;import java.io.IOException;+import java.util.ArrayList;+import java.util.Collection;+import java.util.Comparator;+import java.util.List;/*** A {@link DocIdSetIterator} which is a disjunction of the approximations of the provided@@ -24,18 +28,75 @@ import java.io.IOException;** @lucene.internal*/-public class DisjunctionDISIApproximation extends DocIdSetIterator {+public final class DisjunctionDISIApproximation extends DocIdSetIterator {- final DisiPriorityQueue subIterators;- final long cost;+ public static DisjunctionDISIApproximation of(+ Collection<DisiWrapper> subIterators, long leadCost) {++ return new DisjunctionDISIApproximation(subIterators, leadCost);+ }++ // Heap of iterators that lead iteration.+ private final DisiPriorityQueue leadIterators;+ // List of iterators that will likely advance on every call to nextDoc() / advance()+ private final DisiWrapper[] otherIterators;+ private final long cost;+ private DisiWrapper leadTop;+ private int minOtherDoc;++ public DisjunctionDISIApproximation(Collection<DisiWrapper> subIterators, long leadCost) {+ // Using a heap to store disjunctive clauses is great for exhaustive evaluation, when a single+ // clause needs to move through the heap on every iteration on average. However, when+ // intersecting with a selective filter, it is possible that all clauses need advancing, which+ // makes the reordering cost scale in O(N * log(N)) per advance() call when checking clauses+ // linearly would scale in O(N).+ // To protect against this reordering overhead, we try to have 1.5 clauses or less that advance+ // on every advance() call by only putting clauses into the heap as long as Σ min(1, cost /+ // leadCost) <= 1.5, or Σ min(leadCost, cost) <= 1.5 * leadCost. Other clauses are checked+ // linearly.++ List<DisiWrapper> wrappers = new ArrayList<>(subIterators);+ // Sort by descending cost.+ wrappers.sort(Comparator.<DisiWrapper>comparingLong(w -> w.cost).reversed());++ leadIterators = new DisiPriorityQueue(subIterators.size());++ long reorderThreshold = leadCost + (leadCost >> 1);+ if (reorderThreshold < 0) { // overflow+ reorderThreshold = Long.MAX_VALUE;+ }+ long reorderCost = 0;+ while (wrappers.isEmpty() == false) {+ DisiWrapper last = wrappers.getLast();+ long inc = Math.min(last.cost, leadCost);+ if (reorderCost + inc < 0 || reorderCost + inc > reorderThreshold) {+ break;+ }+ leadIterators.add(wrappers.removeLast());+ reorderCost += inc;+ }++ // Make leadIterators not empty. This helps save conditionals in the implementation which are+ // rarely tested.+ if (leadIterators.size() == 0) {+ leadIterators.add(wrappers.removeLast());+ }++ otherIterators = wrappers.toArray(DisiWrapper[]::new);- public DisjunctionDISIApproximation(DisiPriorityQueue subIterators) {- this.subIterators = subIterators;long cost = 0;- for (DisiWrapper w : subIterators) {+ for (DisiWrapper w : leadIterators) {+ cost += w.cost;+ }+ for (DisiWrapper w : otherIterators) {cost += w.cost;}this.cost = cost;+ minOtherDoc = Integer.MAX_VALUE;+ for (DisiWrapper w : otherIterators) {+ minOtherDoc = Math.min(minOtherDoc, w.doc);+ }+ leadTop = leadIterators.top();}@Override@@ -45,29 +106,62 @@ public class DisjunctionDISIApproximation extends DocIdSetIterator {@Overridepublic int docID() {- return subIterators.top().doc;+ return Math.min(minOtherDoc, leadTop.doc);}@Overridepublic int nextDoc() throws IOException {- DisiWrapper top = subIterators.top();- final int doc = top.doc;- do {- top.doc = top.approximation.nextDoc();- top = subIterators.updateTop();- } while (top.doc == doc);-- return top.doc;+ if (leadTop.doc < minOtherDoc) {+ int curDoc = leadTop.doc;+ do {+ leadTop.doc = leadTop.approximation.nextDoc();+ leadTop = leadIterators.updateTop();+ } while (leadTop.doc == curDoc);+ return Math.min(leadTop.doc, minOtherDoc);+ } else {+ return advance(minOtherDoc + 1);+ }}@Overridepublic int advance(int target) throws IOException {- DisiWrapper top = subIterators.top();- do {- top.doc = top.approximation.advance(target);- top = subIterators.updateTop();- } while (top.doc < target);+ while (leadTop.doc < target) {+ leadTop.doc = leadTop.approximation.advance(target);+ leadTop = leadIterators.updateTop();+ }- return top.doc;+ minOtherDoc = Integer.MAX_VALUE;+ for (DisiWrapper w : otherIterators) {+ if (w.doc < target) {+ w.doc = w.approximation.advance(target);+ }+ minOtherDoc = Math.min(minOtherDoc, w.doc);+ }++ return Math.min(leadTop.doc, minOtherDoc);+ }++ /** Return the linked list of iterators positioned on the current doc. */+ public DisiWrapper topList() {+ if (leadTop.doc < minOtherDoc) {+ return leadIterators.topList();+ } else {+ return computeTopList();+ }+ }++ private DisiWrapper computeTopList() {+ assert leadTop.doc >= minOtherDoc;+ DisiWrapper topList = null;+ if (leadTop.doc == minOtherDoc) {+ topList = leadIterators.topList();+ }+ for (DisiWrapper w : otherIterators) {+ if (w.doc == minOtherDoc) {+ w.next = topList;+ topList = w;+ }+ }+ return topList;}}diff --git a/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java b/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxQuery.javaindex a98dc91ca4e..7255a67419b 100644--- a/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxQuery.java@@ -155,7 +155,7 @@ public final class DisjunctionMaxQuery extends Query implements Iterable<Query>for (ScorerSupplier ss : scorerSuppliers) {scorers.add(ss.get(leadCost));}- return new DisjunctionMaxScorer(tieBreakerMultiplier, scorers, scoreMode);+ return new DisjunctionMaxScorer(tieBreakerMultiplier, scorers, scoreMode, leadCost);}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxScorer.java b/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxScorer.javaindex 58965a5e58f..de8c88fd5af 100644--- a/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/DisjunctionMaxScorer.java@@ -40,9 +40,10 @@ final class DisjunctionMaxScorer extends DisjunctionScorer {* as they are summed into the result.* @param subScorers The sub scorers this Scorer should iterate on*/- DisjunctionMaxScorer(float tieBreakerMultiplier, List<Scorer> subScorers, ScoreMode scoreMode)+ DisjunctionMaxScorer(+ float tieBreakerMultiplier, List<Scorer> subScorers, ScoreMode scoreMode, long leadCost)throws IOException {- super(subScorers, scoreMode);+ super(subScorers, scoreMode, leadCost);this.subScorers = subScorers;this.tieBreakerMultiplier = tieBreakerMultiplier;if (tieBreakerMultiplier < 0 || tieBreakerMultiplier > 1) {diff --git a/lucene/core/src/java/org/apache/lucene/search/DisjunctionScorer.java b/lucene/core/src/java/org/apache/lucene/search/DisjunctionScorer.javaindex 54681f4a8ac..69237ec4e97 100644--- a/lucene/core/src/java/org/apache/lucene/search/DisjunctionScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/DisjunctionScorer.java@@ -25,37 +25,34 @@ import org.apache.lucene.util.PriorityQueue;/** Base class for Scorers that score disjunctions. */abstract class DisjunctionScorer extends Scorer {+ private final int numClauses;private final boolean needsScores;- private final DisiPriorityQueue subScorers;- private final DocIdSetIterator approximation;+ private final DisjunctionDISIApproximation approximation;private final TwoPhase twoPhase;- protected DisjunctionScorer(List<Scorer> subScorers, ScoreMode scoreMode) throws IOException {+ protected DisjunctionScorer(List<Scorer> subScorers, ScoreMode scoreMode, long leadCost)+ throws IOException {if (subScorers.size() <= 1) {throw new IllegalArgumentException("There must be at least 2 subScorers");}- this.subScorers = new DisiPriorityQueue(subScorers.size());- for (Scorer scorer : subScorers) {- final DisiWrapper w = new DisiWrapper(scorer, false);- this.subScorers.add(w);- }+ this.numClauses = subScorers.size();this.needsScores = scoreMode != ScoreMode.COMPLETE_NO_SCORES;- this.approximation = new DisjunctionDISIApproximation(this.subScorers);-boolean hasApproximation = false;float sumMatchCost = 0;long sumApproxCost = 0;- // Compute matchCost as the average over the matchCost of the subScorers.- // This is weighted by the cost, which is an expected number of matching documents.- for (DisiWrapper w : this.subScorers) {+ List<DisiWrapper> wrappers = new ArrayList<>();+ for (Scorer scorer : subScorers) {+ DisiWrapper w = new DisiWrapper(scorer, false);long costWeight = (w.cost <= 1) ? 1 : w.cost;sumApproxCost += costWeight;if (w.twoPhaseView != null) {hasApproximation = true;sumMatchCost += w.matchCost * costWeight;}+ wrappers.add(w);}+ this.approximation = new DisjunctionDISIApproximation(wrappers, leadCost);if (hasApproximation == false) { // no sub scorer supports approximationstwoPhase = null;@@ -91,7 +88,7 @@ abstract class DisjunctionScorer extends Scorer {super(approximation);this.matchCost = matchCost;unverifiedMatches =- new PriorityQueue<DisiWrapper>(DisjunctionScorer.this.subScorers.size()) {+ new PriorityQueue<DisiWrapper>(numClauses) {@Overrideprotected boolean lessThan(DisiWrapper a, DisiWrapper b) {return a.matchCost < b.matchCost;@@ -116,7 +113,7 @@ abstract class DisjunctionScorer extends Scorer {verifiedMatches = null;unverifiedMatches.clear();- for (DisiWrapper w = subScorers.topList(); w != null; ) {+ for (DisiWrapper w = DisjunctionScorer.this.approximation.topList(); w != null; ) {DisiWrapper next = w.next;if (w.twoPhaseView == null) {@@ -160,12 +157,12 @@ abstract class DisjunctionScorer extends Scorer {@Overridepublic final int docID() {- return subScorers.top().doc;+ return approximation.docID();}DisiWrapper getSubMatches() throws IOException {if (twoPhase == null) {- return subScorers.topList();+ return approximation.topList();} else {return twoPhase.getSubMatches();}diff --git a/lucene/core/src/java/org/apache/lucene/search/DisjunctionSumScorer.java b/lucene/core/src/java/org/apache/lucene/search/DisjunctionSumScorer.javaindex fb9648e725f..1a7b7f497e7 100644--- a/lucene/core/src/java/org/apache/lucene/search/DisjunctionSumScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/DisjunctionSumScorer.java@@ -30,8 +30,9 @@ final class DisjunctionSumScorer extends DisjunctionScorer {** @param subScorers Array of at least two subscorers.*/- DisjunctionSumScorer(List<Scorer> subScorers, ScoreMode scoreMode) throws IOException {- super(subScorers, scoreMode);+ DisjunctionSumScorer(List<Scorer> subScorers, ScoreMode scoreMode, long leadCost)+ throws IOException {+ super(subScorers, scoreMode, leadCost);this.scorers = subScorers;}diff --git a/lucene/core/src/java/org/apache/lucene/search/IndriDisjunctionScorer.java b/lucene/core/src/java/org/apache/lucene/search/IndriDisjunctionScorer.javaindex 6836269189d..36e613e47ff 100644--- a/lucene/core/src/java/org/apache/lucene/search/IndriDisjunctionScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/IndriDisjunctionScorer.java@@ -17,6 +17,7 @@package org.apache.lucene.search;import java.io.IOException;+import java.util.ArrayList;import java.util.List;/**@@ -27,18 +28,17 @@ import java.util.List;public abstract class IndriDisjunctionScorer extends IndriScorer {private final List<Scorer> subScorersList;- private final DisiPriorityQueue subScorers;private final DocIdSetIterator approximation;protected IndriDisjunctionScorer(List<Scorer> subScorersList, ScoreMode scoreMode, float boost) {super(boost);this.subScorersList = subScorersList;- this.subScorers = new DisiPriorityQueue(subScorersList.size());+ List<DisiWrapper> wrappers = new ArrayList<>();for (Scorer scorer : subScorersList) {final DisiWrapper w = new DisiWrapper(scorer, false);- this.subScorers.add(w);+ wrappers.add(w);}- this.approximation = new DisjunctionDISIApproximation(this.subScorers);+ this.approximation = new DisjunctionDISIApproximation(wrappers, Long.MAX_VALUE);}@Override@@ -71,6 +71,6 @@ public abstract class IndriDisjunctionScorer extends IndriScorer {@Overridepublic int docID() {- return subScorers.top().doc;+ return approximation.docID();}}diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreBlendedWrapper.java b/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreBlendedWrapper.javaindex 78a75fd2b3f..b4b81f66e6c 100644--- a/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreBlendedWrapper.java+++ b/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreBlendedWrapper.java@@ -17,6 +17,7 @@package org.apache.lucene.search;import java.io.IOException;+import java.util.ArrayList;import java.util.List;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.PostingsEnum;@@ -52,7 +53,8 @@ final class MultiTermQueryConstantScoreBlendedWrapper<Q extends MultiTermQuery>int fieldDocCount,Terms terms,TermsEnum termsEnum,- List<TermAndState> collectedTerms)+ List<TermAndState> collectedTerms,+ long leadCost)throws IOException {DocIdSetBuilder otherTerms = new DocIdSetBuilder(context.reader().maxDoc(), terms);PriorityQueue<PostingsEnum> highFrequencyTerms =@@ -110,7 +112,7 @@ final class MultiTermQueryConstantScoreBlendedWrapper<Q extends MultiTermQuery>}} while (termsEnum.next() != null);- DisiPriorityQueue subs = new DisiPriorityQueue(highFrequencyTerms.size() + 1);+ List<DisiWrapper> subs = new ArrayList<>(highFrequencyTerms.size() + 1);for (DocIdSetIterator disi : highFrequencyTerms) {Scorer s = wrapWithDummyScorer(this, disi);subs.add(new DisiWrapper(s, false));@@ -118,7 +120,7 @@ final class MultiTermQueryConstantScoreBlendedWrapper<Q extends MultiTermQuery>Scorer s = wrapWithDummyScorer(this, otherTerms.build().iterator());subs.add(new DisiWrapper(s, false));- return new WeightOrDocIdSetIterator(new DisjunctionDISIApproximation(subs));+ return new WeightOrDocIdSetIterator(new DisjunctionDISIApproximation(subs, leadCost));}};}diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreWrapper.java b/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreWrapper.javaindex 4a23ddaa006..ff31cbab21c 100644--- a/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreWrapper.java+++ b/lucene/core/src/java/org/apache/lucene/search/MultiTermQueryConstantScoreWrapper.java@@ -49,7 +49,8 @@ final class MultiTermQueryConstantScoreWrapper<Q extends MultiTermQuery>int fieldDocCount,Terms terms,TermsEnum termsEnum,- List<TermAndState> collectedTerms)+ List<TermAndState> collectedTerms,+ long leadCost)throws IOException {DocIdSetBuilder builder = new DocIdSetBuilder(context.reader().maxDoc(), terms);PostingsEnum docs = null;diff --git a/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java b/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.javaindex ef1073116d7..834deede909 100644--- a/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/SynonymQuery.java@@ -357,17 +357,19 @@ public final class SynonymQuery extends Query {} else {// we use termscorers + disjunction as an impl detail- DisiPriorityQueue queue = new DisiPriorityQueue(iterators.size());+ List<DisiWrapper> wrappers = new ArrayList<>();for (int i = 0; i < iterators.size(); i++) {PostingsEnum postings = iterators.get(i);final TermScorer termScorer = new TermScorer(postings, simWeight, norms);float boost = termBoosts.get(i);final DisiWrapperFreq wrapper = new DisiWrapperFreq(termScorer, boost);- queue.add(wrapper);+ wrappers.add(wrapper);}// Even though it is called approximation, it is accurate since none of// the sub iterators are two-phase iterators.- DocIdSetIterator iterator = new DisjunctionDISIApproximation(queue);+ DisjunctionDISIApproximation disjunctionIterator =+ new DisjunctionDISIApproximation(wrappers, leadCost);+ DocIdSetIterator iterator = disjunctionIterator;float[] boosts = new float[impacts.size()];for (int i = 0; i < boosts.length; i++) {@@ -384,7 +386,7 @@ public final class SynonymQuery extends Query {iterator = impactsDisi;}- return new SynonymScorer(queue, iterator, impactsDisi, simWeight, norms);+ return new SynonymScorer(iterator, disjunctionIterator, impactsDisi, simWeight, norms);}}@@ -576,21 +578,21 @@ public final class SynonymQuery extends Query {private static class SynonymScorer extends Scorer {- private final DisiPriorityQueue queue;private final DocIdSetIterator iterator;+ private final DisjunctionDISIApproximation disjunctionDisi;private final MaxScoreCache maxScoreCache;private final ImpactsDISI impactsDisi;private final SimScorer scorer;private final NumericDocValues norms;SynonymScorer(- DisiPriorityQueue queue,DocIdSetIterator iterator,+ DisjunctionDISIApproximation disjunctionDisi,ImpactsDISI impactsDisi,SimScorer scorer,NumericDocValues norms) {- this.queue = queue;this.iterator = iterator;+ this.disjunctionDisi = disjunctionDisi;this.maxScoreCache = impactsDisi.getMaxScoreCache();this.impactsDisi = impactsDisi;this.scorer = scorer;@@ -603,7 +605,7 @@ public final class SynonymQuery extends Query {}float freq() throws IOException {- DisiWrapperFreq w = (DisiWrapperFreq) queue.topList();+ DisiWrapperFreq w = (DisiWrapperFreq) disjunctionDisi.topList();float freq = w.freq();for (w = (DisiWrapperFreq) w.next; w != null; w = (DisiWrapperFreq) w.next) {freq += w.freq();diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.javaindex 0fbcd9e2a9a..1ca3f790f43 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.java@@ -39,7 +39,6 @@ import org.apache.lucene.index.TermsEnum;import org.apache.lucene.search.BooleanClause;import org.apache.lucene.search.BooleanQuery;import org.apache.lucene.search.CollectionStatistics;-import org.apache.lucene.search.DisiPriorityQueue;import org.apache.lucene.search.DisiWrapper;import org.apache.lucene.search.DisjunctionDISIApproximation;import org.apache.lucene.search.DocIdSetIterator;@@ -383,6 +382,7 @@ public final class CombinedFieldQuery extends Query implements Accountable {public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException {List<PostingsEnum> iterators = new ArrayList<>();List<FieldAndWeight> fields = new ArrayList<>();+ long cost = 0;for (int i = 0; i < fieldTerms.length; i++) {IOSupplier<TermState> supplier = termStates[i].get(context);TermState state = supplier == null ? null : supplier.get();@@ -392,6 +392,7 @@ public final class CombinedFieldQuery extends Query implements Accountable {PostingsEnum postingsEnum = termsEnum.postings(null, PostingsEnum.FREQS);iterators.add(postingsEnum);fields.add(fieldAndWeights.get(fieldTerms[i].field()));+ cost += postingsEnum.cost();}}@@ -401,18 +402,31 @@ public final class CombinedFieldQuery extends Query implements Accountable {MultiNormsLeafSimScorer scoringSimScorer =new MultiNormsLeafSimScorer(simWeight, context.reader(), fieldAndWeights.values(), true);- // we use termscorers + disjunction as an impl detail- DisiPriorityQueue queue = new DisiPriorityQueue(iterators.size());- for (int i = 0; i < iterators.size(); i++) {- float weight = fields.get(i).weight;- queue.add(- new WeightedDisiWrapper(new TermScorer(iterators.get(i), simWeight, null), weight));- }- // Even though it is called approximation, it is accurate since none of- // the sub iterators are two-phase iterators.- DocIdSetIterator iterator = new DisjunctionDISIApproximation(queue);- final var scorer = new CombinedFieldScorer(queue, iterator, scoringSimScorer);- return new DefaultScorerSupplier(scorer);++ final long finalCost = cost;+ return new ScorerSupplier() {++ @Override+ public Scorer get(long leadCost) throws IOException {+ // we use termscorers + disjunction as an impl detail+ List<DisiWrapper> wrappers = new ArrayList<>(iterators.size());+ for (int i = 0; i < iterators.size(); i++) {+ float weight = fields.get(i).weight;+ wrappers.add(+ new WeightedDisiWrapper(new TermScorer(iterators.get(i), simWeight, null), weight));+ }+ // Even though it is called approximation, it is accurate since none of+ // the sub iterators are two-phase iterators.+ DisjunctionDISIApproximation iterator =+ new DisjunctionDISIApproximation(wrappers, leadCost);+ return new CombinedFieldScorer(iterator, scoringSimScorer);+ }++ @Override+ public long cost() {+ return finalCost;+ }+ };}@Override@@ -437,14 +451,11 @@ public final class CombinedFieldQuery extends Query implements Accountable {}private static class CombinedFieldScorer extends Scorer {- private final DisiPriorityQueue queue;- private final DocIdSetIterator iterator;+ private final DisjunctionDISIApproximation iterator;private final MultiNormsLeafSimScorer simScorer;private final float maxScore;- CombinedFieldScorer(- DisiPriorityQueue queue, DocIdSetIterator iterator, MultiNormsLeafSimScorer simScorer) {- this.queue = queue;+ CombinedFieldScorer(DisjunctionDISIApproximation iterator, MultiNormsLeafSimScorer simScorer) {this.iterator = iterator;this.simScorer = simScorer;this.maxScore = simScorer.getSimScorer().score(Float.POSITIVE_INFINITY, 1L);@@ -456,7 +467,7 @@ public final class CombinedFieldQuery extends Query implements Accountable {}float freq() throws IOException {- DisiWrapper w = queue.topList();+ DisiWrapper w = iterator.topList();float freq = ((WeightedDisiWrapper) w).freq();for (w = w.next; w != null; w = w.next) {freq += ((WeightedDisiWrapper) w).freq();