Remove HitsThresholdChecker.

lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java

@@ -71,15 +71,14 @@ private abstract class TopFieldLeafCollector implements LeafCollector {
     }
 
     void countHit(int doc) throws IOException {
-      ++totalHits;
-      hitsThresholdChecker.incrementHitCount();
+      int hitCountSoFar = ++totalHits;
 
-      if (minScoreAcc != null && (totalHits & minScoreAcc.modInterval) == 0) {
+      if (minScoreAcc != null && (hitCountSoFar & minScoreAcc.modInterval) == 0) {
         updateGlobalMinCompetitiveScore(scorer);
       }
       if (scoreMode.isExhaustive() == false
           && totalHitsRelation == TotalHits.Relation.EQUAL_TO
-          && hitsThresholdChecker.isThresholdReached()) {
+          && totalHits > totalHitsThreshold) {
         // for the first time hitsThreshold is reached, notify comparator about this
         comparator.setHitsThresholdReached();
         totalHitsRelation = TotalHits.Relation.GREATER_THAN_OR_EQUAL_TO;
@@ -92,7 +91,7 @@ boolean thresholdCheck(int doc) throws IOException {
         // this document is larger than anything else in the queue, and
         // therefore not competitive.
         if (searchSortPartOfIndexSort) {
-          if (hitsThresholdChecker.isThresholdReached()) {
+          if (totalHits > totalHitsThreshold) {
             totalHitsRelation = Relation.GREATER_THAN_OR_EQUAL_TO;
             throw new CollectionTerminatedException();
           } else {
@@ -180,9 +179,9 @@ public SimpleFieldCollector(
         Sort sort,
         FieldValueHitQueue<Entry> queue,
         int numHits,
-        HitsThresholdChecker hitsThresholdChecker,
+        int totalHitsThreshold,
         MaxScoreAccumulator minScoreAcc) {
-      super(queue, numHits, hitsThresholdChecker, sort.needsScores(), minScoreAcc);
+      super(queue, numHits, totalHitsThreshold, sort.needsScores(), minScoreAcc);
       this.sort = sort;
       this.queue = queue;
     }
@@ -235,9 +234,9 @@ public PagingFieldCollector(
         FieldValueHitQueue<Entry> queue,
         FieldDoc after,
         int numHits,
-        HitsThresholdChecker hitsThresholdChecker,
+        int totalHitsThreshold,
         MaxScoreAccumulator minScoreAcc) {
-      super(queue, numHits, hitsThresholdChecker, sort.needsScores(), minScoreAcc);
+      super(queue, numHits, totalHitsThreshold, sort.needsScores(), minScoreAcc);
       this.sort = sort;
       this.queue = queue;
       this.after = after;
@@ -301,7 +300,7 @@ public void collect(int doc) throws IOException {
   private static final ScoreDoc[] EMPTY_SCOREDOCS = new ScoreDoc[0];
 
   final int numHits;
-  final HitsThresholdChecker hitsThresholdChecker;
+  final int totalHitsThreshold;
   final FieldComparator<?> firstComparator;
   final boolean canSetMinScore;
 
@@ -327,25 +326,25 @@ public void collect(int doc) throws IOException {
   private TopFieldCollector(
       FieldValueHitQueue<Entry> pq,
       int numHits,
-      HitsThresholdChecker hitsThresholdChecker,
+      int totalHitsThreshold,
       boolean needsScores,
       MaxScoreAccumulator minScoreAcc) {
     super(pq);
     this.needsScores = needsScores;
     this.numHits = numHits;
-    this.hitsThresholdChecker = hitsThresholdChecker;
+    this.totalHitsThreshold = Math.max(totalHitsThreshold, numHits);
     this.numComparators = pq.getComparators().length;
     this.firstComparator = pq.getComparators()[0];
     int reverseMul = pq.reverseMul[0];
 
     if (firstComparator.getClass().equals(FieldComparator.RelevanceComparator.class)
         && reverseMul == 1 // if the natural sort is preserved (sort by descending relevance)
-        && hitsThresholdChecker.getHitsThreshold() != Integer.MAX_VALUE) {
+        && totalHitsThreshold != Integer.MAX_VALUE) {
       scoreMode = ScoreMode.TOP_SCORES;
       canSetMinScore = true;
     } else {
       canSetMinScore = false;
-      if (hitsThresholdChecker.getHitsThreshold() != Integer.MAX_VALUE) {
+      if (totalHitsThreshold != Integer.MAX_VALUE) {
         scoreMode = needsScores ? ScoreMode.TOP_DOCS_WITH_SCORES : ScoreMode.TOP_DOCS;
       } else {
         scoreMode = needsScores ? ScoreMode.COMPLETE : ScoreMode.COMPLETE_NO_SCORES;
@@ -361,10 +360,10 @@ public ScoreMode scoreMode() {
 
   protected void updateGlobalMinCompetitiveScore(Scorable scorer) throws IOException {
     assert minScoreAcc != null;
-    if (canSetMinScore && hitsThresholdChecker.isThresholdReached()) {
-      // we can start checking the global maximum score even
-      // if the local queue is not full because the threshold
-      // is reached.
+    if (canSetMinScore) {
+      // we can start checking the global maximum score even if the local queue is not full or if
+      // the threshold is not reached on the local competitor: the fact that there is a shared min
+      // competitive score implies that one of the collectors hit its totalHitsThreshold already
       long maxMinScore = minScoreAcc.getRaw();
       float score;
       if (maxMinScore != Long.MIN_VALUE
@@ -377,7 +376,7 @@ protected void updateGlobalMinCompetitiveScore(Scorable scorer) throws IOExcepti
   }
 
   protected void updateMinCompetitiveScore(Scorable scorer) throws IOException {
-    if (canSetMinScore && queueFull && hitsThresholdChecker.isThresholdReached()) {
+    if (canSetMinScore && queueFull && totalHits > totalHitsThreshold) {
       assert bottom != null;
       float minScore = (float) firstComparator.value(bottom.slot);
       if (minScore > minCompetitiveScore) {

lucene/core/src/java/org/apache/lucene/search/TopFieldCollectorManager.java

@@ -32,7 +32,7 @@ public class TopFieldCollectorManager implements CollectorManager<TopFieldCollec
   private final Sort sort;
   private final int numHits;
   private final FieldDoc after;
-  private final HitsThresholdChecker hitsThresholdChecker;
+  private final int totalHitsThreshold;
   private final MaxScoreAccumulator minScoreAcc;
   private final List<TopFieldCollector> collectors;
   private final boolean supportsConcurrency;
@@ -89,10 +89,7 @@ public TopFieldCollectorManager(
     this.numHits = numHits;
     this.after = after;
     this.supportsConcurrency = supportsConcurrency;
-    this.hitsThresholdChecker =
-        supportsConcurrency
-            ? HitsThresholdChecker.createShared(Math.max(totalHitsThreshold, numHits))
-            : HitsThresholdChecker.create(Math.max(totalHitsThreshold, numHits));
+    this.totalHitsThreshold = totalHitsThreshold;
     this.minScoreAcc = supportsConcurrency ? new MaxScoreAccumulator() : null;
     this.collectors = new ArrayList<>();
   }
@@ -159,7 +156,7 @@ public TopFieldCollector newCollector() {
       }
       collector =
           new TopFieldCollector.SimpleFieldCollector(
-              sort, queue, numHits, hitsThresholdChecker, minScoreAcc);
+              sort, queue, numHits, totalHitsThreshold, minScoreAcc);
     } else {
       if (after.fields == null) {
         throw new IllegalArgumentException(
@@ -175,7 +172,7 @@ public TopFieldCollector newCollector() {
       }
       collector =
           new TopFieldCollector.PagingFieldCollector(
-              sort, queue, after, numHits, hitsThresholdChecker, minScoreAcc);
+              sort, queue, after, numHits, totalHitsThreshold, minScoreAcc);
     }
 
     collectors.add(collector);