Use IndexInput#prefetch for terms dictionary lookups.

lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnum.java

@@ -31,6 +31,8 @@
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.BytesRefBuilder;
 import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.lucene.util.fst.BytesRefFSTEnum;
+import org.apache.lucene.util.fst.BytesRefFSTEnum.InputOutput;
 import org.apache.lucene.util.fst.FST;
 import org.apache.lucene.util.fst.Util;
 
@@ -307,6 +309,31 @@ private boolean setEOF() {
     return true;
   }
 
+  @Override
+  public void prepareSeekExact(BytesRef target) throws IOException {
+    if (fr.index == null) {
+      throw new IllegalStateException("terms index was not loaded");
+    }
+
+    if (fr.size() == 0 || target.compareTo(fr.getMin()) < 0 || target.compareTo(fr.getMax()) > 0) {
+      return;
+    }
+
+    // TODO: should we try to reuse the current state of this terms enum when applicable?
+    BytesRefFSTEnum<BytesRef> indexEnum = new BytesRefFSTEnum<>(fr.index);
+    InputOutput<BytesRef> output = indexEnum.seekFloor(target);
+    final long code =
+        fr.readVLongOutput(
+            new ByteArrayDataInput(
+                output.output.bytes, output.output.offset, output.output.length));
+    final long fpSeek = code >>> Lucene90BlockTreeTermsReader.OUTPUT_FLAGS_NUM_BITS;
+    initIndexInput();
+    final long fp = in.getFilePointer();
+    in.seek(fpSeek);
+    in.prefetch(1); // TODO: could we know the length of the block?
+    in.seek(fp); // TODO: do we actually need to do this?
+  }
+
   @Override
   public boolean seekExact(BytesRef target) throws IOException {
 

lucene/core/src/java/org/apache/lucene/index/TermStates.java

@@ -17,10 +17,12 @@
 package org.apache.lucene.index;
 
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.Callable;
+import java.util.function.Supplier;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.TaskExecutor;
 
@@ -179,15 +181,39 @@ public void accumulateStatistics(final int docFreq, final long totalTermFreq) {
    * @return the {@link TermState} for the given readers ord or <code>null</code> if no {@link
    *     TermState} for the reader was registered
    */
-  public TermState get(LeafReaderContext ctx) throws IOException {
+  public Supplier<TermState> get(LeafReaderContext ctx) throws IOException {
     assert ctx.ord >= 0 && ctx.ord < states.length;
-    if (term == null) return states[ctx.ord];
+    if (term == null) return () -> states[ctx.ord];
     if (this.states[ctx.ord] == null) {
-      TermsEnum te = loadTermsEnum(ctx, term);
-      this.states[ctx.ord] = te == null ? EMPTY_TERMSTATE : te.termState();
+      final Terms terms = Terms.getTerms(ctx.reader(), term.field());
+      final TermsEnum termsEnum = terms.iterator();
+      termsEnum.prepareSeekExact(term.bytes());
+      return () -> {
+        if (this.states[ctx.ord] == null) {
+          try {
+            TermState state = null;
+            if (termsEnum.seekExact(term.bytes())) {
+              state = termsEnum.termState();
+            }
+            this.states[ctx.ord] = state == null ? EMPTY_TERMSTATE : state;
+          } catch (IOException e) {
+            throw new UncheckedIOException(e);
+          }
+        }
+        TermState state = this.states[ctx.ord];
+        if (state == EMPTY_TERMSTATE) {
+          return null;
+        }
+        return state;
+      };
     }
-    if (this.states[ctx.ord] == EMPTY_TERMSTATE) return null;
-    return this.states[ctx.ord];
+    return () -> {
+      TermState state = this.states[ctx.ord];
+      if (state == EMPTY_TERMSTATE) {
+        return null;
+      }
+      return state;
+    };
   }
 
   /**

lucene/core/src/java/org/apache/lucene/index/TermsEnum.java

@@ -17,6 +17,7 @@
 package org.apache.lucene.index;
 
 import java.io.IOException;
+import org.apache.lucene.store.IndexInput;
 import org.apache.lucene.util.AttributeSource;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.BytesRefIterator;
@@ -61,6 +62,15 @@ public enum SeekStatus {
    */
   public abstract boolean seekExact(BytesRef text) throws IOException;
 
+  /**
+   * Prepare a future call to {@link #seekExact}. This typically calls {@link IndexInput#prefetch}
+   * on the right range of bytes under the hood so that the next call to {@link #seekExact} is
+   * faster. This can be used to parallelize I/O across multiple terms by calling {@link
+   * #prepareSeekExact} on multiple terms enums before calling {@link #seekExact(BytesRef)} on the
+   * same {@link TermsEnum}s.
+   */
+  public void prepareSeekExact(BytesRef text) throws IOException {}
+
   /**
    * Seeks to the specified term, if it exists, or to the next (ceiling) term. Returns SeekStatus to
    * indicate whether exact term was found, a different term was found, or EOF was hit. The target

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

@@ -316,7 +316,7 @@ private static TermStates adjustFrequencies(
     List<LeafReaderContext> leaves = readerContext.leaves();
     TermStates newCtx = new TermStates(readerContext);
     for (int i = 0; i < leaves.size(); ++i) {
-      TermState termState = ctx.get(leaves.get(i));
+      TermState termState = ctx.get(leaves.get(i)).get();
       if (termState == null) {
         continue;
       }

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

@@ -277,7 +277,7 @@ protected PhraseMatcher getPhraseMatcher(
           List<PostingsEnum> postings = new ArrayList<>();
 
           for (Term term : terms) {
-            TermState termState = termStates.get(term).get(context);
+            TermState termState = termStates.get(term).get(context).get();
             if (termState != null) {
               termsEnum.seekExact(term.bytes(), termState);
               postings.add(

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

@@ -501,7 +501,7 @@ protected PhraseMatcher getPhraseMatcher(
 
         for (int i = 0; i < terms.length; i++) {
           final Term t = terms[i];
-          final TermState state = states[i].get(context);
+          final TermState state = states[i].get(context).get();
           if (state == null) {
             /* term doesnt exist in this segment */
             assert termNotInReader(reader, t) : "no termstate found but term exists in reader";

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

@@ -281,7 +281,7 @@ public Scorer scorer(LeafReaderContext context) throws IOException {
       List<ImpactsEnum> impacts = new ArrayList<>();
       List<Float> termBoosts = new ArrayList<>();
       for (int i = 0; i < terms.length; i++) {
-        TermState state = termStates[i].get(context);
+        TermState state = termStates[i].get(context).get();
         if (state != null) {
           TermsEnum termsEnum = context.reader().terms(field).iterator();
           termsEnum.seekExact(terms[i].term, state);

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

@@ -17,7 +17,9 @@
 package org.apache.lucene.search;
 
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.util.Objects;
+import java.util.function.Supplier;
 import org.apache.lucene.index.IndexReaderContext;
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
@@ -119,18 +121,34 @@ public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOExcepti
           : "The top-reader used to create Weight is not the same as the current reader's top-reader ("
               + ReaderUtil.getTopLevelContext(context);
 
-      final TermsEnum termsEnum = getTermsEnum(context);
-      if (termsEnum == null) {
-        return null;
-      }
-      final int docFreq = termsEnum.docFreq();
+      final Supplier<TermState> stateSupplier = termStates.get(context);
 
       return new ScorerSupplier() {
 
+        private TermsEnum termsEnum;
         private boolean topLevelScoringClause = false;
 
+        private TermsEnum getTermsEnum() throws IOException {
+          if (termsEnum == null) {
+            TermState state = stateSupplier.get();
+            if (state == null) {
+              return null;
+            }
+            termsEnum = context.reader().terms(term.field()).iterator();
+            termsEnum.seekExact(term.bytes(), state);
+          }
+          return termsEnum;
+        }
+
         @Override
         public Scorer get(long leadCost) throws IOException {
+          TermsEnum termsEnum = getTermsEnum();
+          if (termsEnum == null) {
+            // nocommit: should we start allowing ScorerSupplier#get to return null?
+            return new ConstantScoreScorer(
+                TermWeight.this, 0f, scoreMode, DocIdSetIterator.empty());
+          }
+
           LeafSimScorer scorer =
               new LeafSimScorer(simScorer, context.reader(), term.field(), scoreMode.needsScores());
           if (scoreMode == ScoreMode.TOP_SCORES) {
@@ -150,7 +168,12 @@ public Scorer get(long leadCost) throws IOException {
 
         @Override
         public long cost() {
-          return docFreq;
+          try {
+            TermsEnum te = getTermsEnum();
+            return te == null ? 0 : te.docFreq();
+          } catch (IOException e) {
+            throw new UncheckedIOException(e);
+          }
         }
 
         @Override
@@ -183,7 +206,7 @@ private TermsEnum getTermsEnum(LeafReaderContext context) throws IOException {
       assert termStates.wasBuiltFor(ReaderUtil.getTopLevelContext(context))
           : "The top-reader used to create Weight is not the same as the current reader's top-reader ("
               + ReaderUtil.getTopLevelContext(context);
-      final TermState state = termStates.get(context);
+      final TermState state = termStates.get(context).get();
       if (state == null) { // term is not present in that reader
         assert termNotInReader(context.reader(), term)
             : "no termstate found but term exists in reader term=" + term;

lucene/queries/src/java/org/apache/lucene/queries/spans/SpanTermQuery.java

@@ -135,7 +135,7 @@ public Spans getSpans(final LeafReaderContext context, Postings requiredPostings
           : "The top-reader used to create Weight is not the same as the current reader's top-reader ("
               + ReaderUtil.getTopLevelContext(context);
 
-      final TermState state = termStates.get(context);
+      final TermState state = termStates.get(context).get();
       if (state == null) { // term is not present in that reader
         assert context.reader().docFreq(term) == 0
             : "no termstate found but term exists in reader term=" + term;

lucene/sandbox/src/java/org/apache/lucene/sandbox/search/CombinedFieldQuery.java

@@ -404,7 +404,7 @@ public Scorer scorer(LeafReaderContext context) throws IOException {
       List<PostingsEnum> iterators = new ArrayList<>();
       List<FieldAndWeight> fields = new ArrayList<>();
       for (int i = 0; i < fieldTerms.length; i++) {
-        TermState state = termStates[i].get(context);
+        TermState state = termStates[i].get(context).get();
         if (state != null) {
           TermsEnum termsEnum = context.reader().terms(fieldTerms[i].field()).iterator();
           termsEnum.seekExact(fieldTerms[i].bytes(), state);

lucene/sandbox/src/java/org/apache/lucene/sandbox/search/PhraseWildcardQuery.java

@@ -387,7 +387,7 @@ protected int collectSingleTermData(
       Terms terms = leafReaderContext.reader().terms(term.field());
       if (terms != null) {
         checkTermsHavePositions(terms);
-        TermState termState = termStates.get(leafReaderContext);
+        TermState termState = termStates.get(leafReaderContext).get();
         if (termState != null) {
           termMatchesInSegment = true;
           numMatches++;

lucene/sandbox/src/java/org/apache/lucene/sandbox/search/TermAutomatonQuery.java

@@ -415,7 +415,7 @@ public Scorer scorer(LeafReaderContext context) throws IOException {
             : "The top-reader used to create Weight is not the same as the current reader's top-reader ("
                 + ReaderUtil.getTopLevelContext(context);
         BytesRef term = idToTerm.get(ent.getKey());
-        TermState state = termStates.get(context);
+        TermState state = termStates.get(context).get();
         if (state != null) {
           TermsEnum termsEnum = context.reader().terms(field).iterator();
           termsEnum.seekExact(term, state);