Map from IOContext to ReadAdvice

Author: thecoop

lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene50/Lucene50CompoundReader.java

@@ -171,7 +171,7 @@ public IndexInput openInput(String name, IOContext context) throws IOException {
               + entries.keySet()
               + ")");
     }
-    return handle.slice(name, entry.offset, entry.length, context.readAdvice());
+    return handle.slice(name, entry.offset, entry.length, toReadAdvice(context));
   }
 
   /** Returns an array of strings, one for each file in the directory. */

lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextCompoundFormat.java

@@ -140,7 +140,7 @@ public IndexInput openInput(String name, IOContext context) throws IOException {
             name,
             startOffsets[index],
             endOffsets[index] - startOffsets[index],
-            context.readAdvice());
+            toReadAdvice(context));
       }
 
       @Override

lucene/core/src/java/org/apache/lucene/codecs/lucene90/Lucene90CompoundReader.java

@@ -169,7 +169,7 @@ public IndexInput openInput(String name, IOContext context) throws IOException {
               + entries.keySet()
               + ")");
     }
-    return handle.slice(name, entry.offset, entry.length, context.readAdvice());
+    return handle.slice(name, entry.offset, entry.length, toReadAdvice(context));
   }
 
   /** Returns an array of strings, one for each file in the directory. */

lucene/core/src/java/org/apache/lucene/store/DefaultIOContext.java

@@ -18,18 +18,16 @@
 
 import java.util.Arrays;
 import java.util.Objects;
-import org.apache.lucene.util.Constants;
+import java.util.Optional;
 
-record DefaultIOContext(ReadAdvice readAdvice, FileOpenHint... hints) implements IOContext {
+record DefaultIOContext(Optional<ReadAdvice> readAdvice, FileOpenHint... hints)
+    implements IOContext {
 
   public DefaultIOContext {
     Objects.requireNonNull(readAdvice);
     Objects.requireNonNull(hints);
-
-    // either hints or readadvice should be specified, not both
-    if (hints.length > 0 && readAdvice != Constants.DEFAULT_READADVICE) {
-      throw new IllegalArgumentException("Either readAdvice or hints should be specified");
-    }
+    if (readAdvice.isPresent() && hints.length > 0)
+      throw new IllegalArgumentException("Either ReadAdvice or hints can be specified, not both");
   }
 
   @Override
@@ -47,9 +45,18 @@ public FlushInfo flushInfo() {
     return null;
   }
 
+  @Override
+  public IOContext withHints(FileOpenHint... hints) {
+    if (readAdvice.isPresent())
+      throw new IllegalArgumentException("ReadAdvice has been specified directly");
+    if (hints.length > 0) // TODO: see if this is needed or not
+    throw new IllegalArgumentException("Hints have already been specified");
+    return new DefaultIOContext(Optional.empty(), hints);
+  }
+
   private static final DefaultIOContext[] READADVICE_TO_IOCONTEXT =
       Arrays.stream(ReadAdvice.values())
-          .map(DefaultIOContext::new)
+          .map(r -> new DefaultIOContext(Optional.of(r)))
           .toArray(DefaultIOContext[]::new);
 
   @Override

lucene/core/src/java/org/apache/lucene/store/Directory.java

@@ -27,6 +27,7 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.apache.lucene.index.IndexFileNames;
+import org.apache.lucene.util.Constants;
 import org.apache.lucene.util.IOUtils;
 
 /**
@@ -105,6 +106,10 @@ protected void validateIOContext(IOContext context) {
     }
   }
 
+  protected ReadAdvice toReadAdvice(IOContext context) {
+    return context.readAdvice().orElse(Constants.DEFAULT_READADVICE);
+  }
+
   /**
    * Creates a new, empty file in the directory and returns an {@link IndexOutput} instance for
    * appending data to this file.

lucene/core/src/java/org/apache/lucene/store/IOContext.java

@@ -17,7 +17,7 @@
 package org.apache.lucene.store;
 
 import java.util.Objects;
-import org.apache.lucene.util.Constants;
+import java.util.Optional;
 
 /**
  * IOContext holds additional details on the merge/search context. An IOContext object can never be
@@ -47,19 +47,15 @@ interface FileOpenHint {}
    * <p>It will use {@link ReadAdvice#RANDOM} by default, unless set by system property {@code
    * org.apache.lucene.store.defaultReadAdvice}.
    */
-  IOContext DEFAULT = new DefaultIOContext(Constants.DEFAULT_READADVICE);
+  IOContext DEFAULT = new DefaultIOContext(Optional.empty());
 
   /**
    * A default context for reads with {@link ReadAdvice#SEQUENTIAL}.
    *
    * <p>This context should only be used when the read operations will be performed in the same
    * thread as the thread that opens the underlying storage.
    */
-  IOContext READONCE = new DefaultIOContext(ReadAdvice.SEQUENTIAL);
-
-  static IOContext defaultContext(FileOpenHint... hints) {
-    return new DefaultIOContext(Constants.DEFAULT_READADVICE, hints);
-  }
+  IOContext READONCE = new DefaultIOContext(Optional.of(ReadAdvice.SEQUENTIAL));
 
   /** Returns an {@link IOContext} for merging with the specified {@link MergeInfo} */
   static IOContext merge(MergeInfo mergeInfo) {
@@ -86,8 +82,13 @@ public FileOpenHint[] hints() {
       }
 
       @Override
-      public ReadAdvice readAdvice() {
-        return ReadAdvice.SEQUENTIAL;
+      public IOContext withHints(FileOpenHint... hints) {
+        return this;
+      }
+
+      @Override
+      public Optional<ReadAdvice> readAdvice() {
+        return Optional.of(ReadAdvice.SEQUENTIAL);
       }
 
       @Override
@@ -122,8 +123,13 @@ public FileOpenHint[] hints() {
       }
 
       @Override
-      public ReadAdvice readAdvice() {
-        return ReadAdvice.SEQUENTIAL;
+      public IOContext withHints(FileOpenHint... hints) {
+        return this;
+      }
+
+      @Override
+      public Optional<ReadAdvice> readAdvice() {
+        return Optional.of(ReadAdvice.SEQUENTIAL);
       }
 
       @Override
@@ -145,9 +151,12 @@ public IOContext withReadAdvice(ReadAdvice advice) {
   /** Any hints on how the file will be opened */
   FileOpenHint[] hints();
 
+  /** Sets the hints on this IOContext, if it makes sense to do so for this specific context */
+  IOContext withHints(FileOpenHint... hints);
+
   /** Advice on the expected read access pattern */
   @Deprecated
-  ReadAdvice readAdvice();
+  Optional<ReadAdvice> readAdvice();
 
   /**
    * Return an updated {@link IOContext} that has the provided {@link ReadAdvice}, if the provided

lucene/core/src/java/org/apache/lucene/store/MMapDirectory.java

@@ -129,13 +129,6 @@ public class MMapDirectory extends FSDirectory {
         return Optional.of(groupKey);
       };
 
-  /**
-   * Argument for {@link #setPreload(BiPredicate)} that configures files to be preloaded upon
-   * opening them if they use the {@link ReadAdvice#RANDOM_PRELOAD} advice.
-   */
-  public static final BiPredicate<String, IOContext> BASED_ON_LOAD_IO_CONTEXT =
-      (_, context) -> context.readAdvice() == ReadAdvice.RANDOM_PRELOAD;
-
   private BiPredicate<String, IOContext> preload = NO_FILES;
 
   /**
@@ -268,8 +261,9 @@ public IndexInput openInput(String name, IOContext context) throws IOException {
     Path path = directory.resolve(name);
     return PROVIDER.openInput(
         path,
-        context,
         chunkSizePower,
+        toReadAdvice(context),
+        context == IOContext.READONCE,
         preload.test(name, context),
         groupingFunction.apply(name),
         attachment);
@@ -281,8 +275,9 @@ public IndexInput openInput(String name, IOContext context) throws IOException {
   interface MMapIndexInputProvider<A> {
     IndexInput openInput(
         Path path,
-        IOContext context,
         int chunkSizePower,
+        ReadAdvice readAdvice,
+        boolean readOnce,
         boolean preload,
         Optional<String> group,
         A attachment)

lucene/core/src/java21/org/apache/lucene/store/MemorySegmentIndexInputProvider.java

@@ -45,8 +45,9 @@ final class MemorySegmentIndexInputProvider
   @Override
   public IndexInput openInput(
       Path path,
-      IOContext context,
       int chunkSizePower,
+      ReadAdvice readAdvice,
+      boolean confined,
       boolean preload,
       Optional<String> group,
       ConcurrentHashMap<String, RefCountedSharedArena> arenas)
@@ -57,22 +58,14 @@ public IndexInput openInput(
     path = Unwrappable.unwrapAll(path);
 
     boolean success = false;
-    final boolean confined = context == IOContext.READONCE;
     final Arena arena = confined ? Arena.ofConfined() : getSharedArena(group, arenas);
     try (var fc = FileChannel.open(path, StandardOpenOption.READ)) {
       final long fileSize = fc.size();
       final IndexInput in =
           MemorySegmentIndexInput.newInstance(
               resourceDescription,
               arena,
-              map(
-                  arena,
-                  resourceDescription,
-                  fc,
-                  context.readAdvice(),
-                  chunkSizePower,
-                  preload,
-                  fileSize),
+              map(arena, resourceDescription, fc, readAdvice, chunkSizePower, preload, fileSize),
               fileSize,
               chunkSizePower,
               confined);

lucene/core/src/test/org/apache/lucene/store/TestDirectory.java

@@ -134,18 +134,19 @@ public void testValidateIOContext() throws Exception {
           IllegalArgumentException.class,
           () ->
               fsDir.createOutput(
-                  "file", IOContext.defaultContext(FileTypeHint.DATA, FileTypeHint.METADATA)));
+                  "file", IOContext.DEFAULT.withHints(FileTypeHint.DATA, FileTypeHint.METADATA)));
       expectThrows(
           IllegalArgumentException.class,
           () ->
               fsDir.createOutput(
-                  "file", IOContext.defaultContext(FileDataHint.VECTORS, FileDataHint.POSTINGS)));
+                  "file",
+                  IOContext.DEFAULT.withHints(FileDataHint.VECTORS, FileDataHint.POSTINGS)));
       expectThrows(
           IllegalArgumentException.class,
           () ->
               fsDir.createOutput(
                   "file",
-                  IOContext.defaultContext(DataAccessHint.RANDOM, DataAccessHint.SEQUENTIAL)));
+                  IOContext.DEFAULT.withHints(DataAccessHint.RANDOM, DataAccessHint.SEQUENTIAL)));
     }
   }
 }

lucene/test-framework/src/java/org/apache/lucene/tests/store/MockDirectoryWrapper.java

@@ -814,7 +814,7 @@ public synchronized IndexInput openInput(String name, IOContext context) throws
     }
 
     // record the read advice before randomizing the context
-    ReadAdvice readAdvice = context.readAdvice();
+    ReadAdvice readAdvice = toReadAdvice(context);
     context = LuceneTestCase.newIOContext(randomState, context);
     final boolean confined = context == IOContext.READONCE;
     if (name.startsWith(IndexFileNames.SEGMENTS) && confined == false) {

lucene/test-framework/src/java/org/apache/lucene/tests/store/SerialIOCountingDirectory.java

@@ -71,12 +71,13 @@ public ChecksumIndexInput openChecksumInput(String name) throws IOException {
 
   @Override
   public IndexInput openInput(String name, IOContext context) throws IOException {
-    if (context.readAdvice() == ReadAdvice.RANDOM_PRELOAD) {
+    if (toReadAdvice(context) == ReadAdvice.RANDOM_PRELOAD) {
       // expected to be loaded in memory, only count 1 at open time
       counter.increment();
       return super.openInput(name, context);
     }
-    return new SerializedIOCountingIndexInput(super.openInput(name, context), context.readAdvice());
+    return new SerializedIOCountingIndexInput(
+        super.openInput(name, context), toReadAdvice(context));
   }
 
   private class SerializedIOCountingIndexInput extends IndexInput {