Enable zero-copy SIMD vector scoring on searchable snapshots (frozen tier)

docs/changelog/141718.yaml

@@ -0,0 +1,5 @@
+area: Vector Search
+issues: []
+pr: 141718
+summary: Enable zero-copy SIMD vector scoring on searchable snapshots (frozen tier)
+type: enhancement

libs/core/src/main/java/org/elasticsearch/core/DirectAccessInput.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.core;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * An optional interface that an IndexInput can implement to provide direct
+ * access to the underlying data as a {@link ByteBuffer}. This enables
+ * zero-copy access to memory-mapped data for SIMD-accelerated vector scoring.
+ *
+ * <p> The byte buffer is passed to the caller's action and is only valid for
+ * the duration of that call. All ref-counting and resource releases, if any,
+ * is handled internally.
+ */
+public interface DirectAccessInput {
+
+    /**
+     * If a direct byte buffer view is available for the given range, passes it
+     * to {@code action} and returns {@code true}. Otherwise returns
+     * {@code false} without invoking the action.
+     *
+     * <p>The byte buffer is read-only and valid only for the duration of the
+     * action. Callers must not retain references to it after the action returns.
+     *
+     * @param offset the byte offset within the input
+     * @param length the number of bytes requested
+     * @param action the action to perform with the byte buffer
+     * @return {@code true} if a buffer was available and the action was invoked
+     */
+    boolean withByteBufferSlice(long offset, long length, CheckedConsumer<ByteBuffer, IOException> action) throws IOException;
+}

libs/native/src/main/java/module-info.java

@@ -20,8 +20,10 @@
         to
             org.elasticsearch.server,
             org.elasticsearch.blobcache,
+            org.elasticsearch.searchablesnapshots,
             org.elasticsearch.simdvec,
-            org.elasticsearch.systemd;
+            org.elasticsearch.systemd,
+            org.elasticsearch.xpack.stateless;
 
     uses NativeLibraryProvider;
 

libs/simdvec/src/main/java/module-info.java

@@ -26,9 +26,10 @@
  * at runtime is selected by the multi-release classloader.
  */
 module org.elasticsearch.simdvec {
+    requires org.elasticsearch.base;
+    requires org.elasticsearch.logging;
     requires org.elasticsearch.nativeaccess;
     requires org.apache.lucene.core;
-    requires org.elasticsearch.logging;
 
     exports org.elasticsearch.simdvec to org.elasticsearch.server;
 }

libs/simdvec/src/main/java/org/elasticsearch/simdvec/MemorySegmentAccessInputAccess.java

@@ -15,8 +15,10 @@
 import java.util.Objects;
 
 public interface MemorySegmentAccessInputAccess {
+    /** Returns the underlying {@link MemorySegmentAccessInput}, or {@code null} if not available. */
     MemorySegmentAccessInput get();
 
+    /** Unwraps to the underlying {@link MemorySegmentAccessInput} if available, otherwise returns the input unchanged. */
     static IndexInput unwrap(IndexInput input) {
         MemorySegmentAccessInput memorySeg = input instanceof MemorySegmentAccessInputAccess msaia ? msaia.get() : null;
         return Objects.requireNonNullElse((IndexInput) memorySeg, input);

libs/simdvec/src/main/java/org/elasticsearch/simdvec/internal/vectorization/ESVectorizationProvider.java

@@ -33,6 +33,14 @@ public static ESVectorizationProvider getInstance() {
     /** Create a new {@link ES91OSQVectorsScorer} for the given {@link IndexInput}. */
     public abstract ES91OSQVectorsScorer newES91OSQVectorsScorer(IndexInput input, int dimension, int bulkSize) throws IOException;
 
+    /**
+     * Create a new {@link ESNextOSQVectorsScorer} for the given {@link IndexInput}.
+     * The input should be unwrapped before calling this method. If the input is
+     * still a {@code FilterIndexInput} that does not implement
+     * {@code MemorySegmentAccessInput} or {@code DirectAccessInput}, an
+     * {@link IllegalArgumentException} is thrown. Non-wrapper inputs (e.g.
+     * {@code ByteBuffersIndexInput}) are accepted and use a heap-copy fallback.
+     */
     public abstract ESNextOSQVectorsScorer newESNextOSQVectorsScorer(
         IndexInput input,
         byte queryBits,
@@ -42,7 +50,10 @@ public abstract ESNextOSQVectorsScorer newESNextOSQVectorsScorer(
         int bulkSize
     ) throws IOException;
 
-    /** Create a new {@link ES92Int7VectorsScorer} for the given {@link IndexInput}. */
+    /**
+     * Create a new {@link ES92Int7VectorsScorer} for the given {@link IndexInput}.
+     * See {@link #newESNextOSQVectorsScorer} for input type requirements.
+     */
     public abstract ES92Int7VectorsScorer newES92Int7VectorsScorer(IndexInput input, int dimension, int bulkSize) throws IOException;
 
     // visible for tests

libs/simdvec/src/main21/java/org/elasticsearch/simdvec/internal/IndexInputUtils.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+package org.elasticsearch.simdvec.internal;
+
+import org.apache.lucene.store.FilterIndexInput;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.MemorySegmentAccessInput;
+import org.elasticsearch.core.CheckedFunction;
+import org.elasticsearch.core.DirectAccessInput;
+
+import java.io.IOException;
+import java.lang.foreign.MemorySegment;
+import java.util.function.IntFunction;
+
+/**
+ * Utility for obtaining a {@link MemorySegment} view of data in an
+ * {@link IndexInput} and passing it to a caller-supplied action. The
+ * segment may come from a {@link MemorySegmentAccessInput} (mmap),
+ * a direct {@link java.nio.ByteBuffer} view (e.g. blob-cache), or a
+ * heap copy as a last resort.
+ *
+ * <p>All resource management (ref-counting, buffer release) is handled
+ * internally — callers never see a closeable resource.
+ */
+public final class IndexInputUtils {
+
+    private IndexInputUtils() {}
+
+    /**
+     * Obtains a memory segment for the next {@code length} bytes of the
+     * index input, passes it to {@code action}, and returns the result.
+     * The position of the index input is advanced by {@code length}.
+     *
+     * <p> This method first tries to obtain a slice via
+     * {@link MemorySegmentAccessInput#segmentSliceOrNull}. If that
+     * returns {@code null}, it tries a direct {@link java.nio.ByteBuffer}
+     * view via {@link DirectAccessInput}. As a last resort it copies the
+     * data onto the heap using a byte array obtained from
+     * {@code scratchSupplier}.
+     *
+     * <p> The memory segment passed to {@code action} is valid only for
+     * the duration of the call. Callers must not retain references to it.
+     *
+     * @param in              the index input positioned at the data to read
+     * @param length          the number of bytes to read
+     * @param scratchSupplier supplies a byte array of at least the requested
+     *                        length, used only on the heap-copy fallback path
+     * @param action          the function to apply to the memory segment
+     * @return the result of applying {@code action}
+     */
+    public static <R> R withSlice(
+        IndexInput in,
+        long length,
+        IntFunction<byte[]> scratchSupplier,
+        CheckedFunction<MemorySegment, R, IOException> action
+    ) throws IOException {
+        checkInputType(in);
+        if (in instanceof MemorySegmentAccessInput msai) {
+            long offset = in.getFilePointer();
+            MemorySegment slice = msai.segmentSliceOrNull(offset, length);
+            if (slice != null) {
+                in.skipBytes(length);
+                return action.apply(slice);
+            }
+        }
+        if (in instanceof DirectAccessInput dai) {
+            long offset = in.getFilePointer();
+            @SuppressWarnings("unchecked")
+            R[] result = (R[]) new Object[1];
+            boolean available = dai.withByteBufferSlice(offset, length, bb -> {
+                in.skipBytes(length);
+                result[0] = action.apply(MemorySegment.ofBuffer(bb));
+            });
+            if (available) {
+                return result[0];
+            }
+        }
+        return action.apply(copyOnHeap(in, Math.toIntExact(length), scratchSupplier));
+    }
+
+    /**
+     * Checks that a {@link FilterIndexInput} wrapper also implements
+     * {@link MemorySegmentAccessInput} or {@link DirectAccessInput},
+     * so that zero-copy access is preserved through the wrapper chain.
+     */
+    public static void checkInputType(IndexInput in) {
+        if (in instanceof FilterIndexInput && (in instanceof MemorySegmentAccessInput || in instanceof DirectAccessInput) == false) {
+            throw new IllegalArgumentException(
+                "IndexInput is a FilterIndexInput ("
+                    + in.getClass().getName()
+                    + ") that does not implement MemorySegmentAccessInput or DirectAccessInput. "
+                    + "Ensure the wrapper implements DirectAccessInput or is unwrapped before constructing the scorer."
+            );
+        }
+    }
+
+    /**
+     * Reads the given number of bytes from the current position of the
+     * given IndexInput into a heap-backed memory segment. The returned
+     * segment is sliced to exactly {@code bytesToRead} bytes, even if
+     * the underlying array is larger.
+     */
+    private static MemorySegment copyOnHeap(IndexInput in, int bytesToRead, IntFunction<byte[]> scratchSupplier) throws IOException {
+        byte[] buf = scratchSupplier.apply(bytesToRead);
+        in.readBytes(buf, 0, bytesToRead);
+        return MemorySegment.ofArray(buf).asSlice(0, bytesToRead);
+    }
+}

libs/simdvec/src/main21/java/org/elasticsearch/simdvec/internal/MemorySegmentES92Int7VectorsScorer.java

@@ -12,13 +12,12 @@
 import org.apache.lucene.store.IndexInput;
 
 import java.io.IOException;
-import java.lang.foreign.MemorySegment;
 
 /** Panamized scorer for 7-bit quantized vectors stored as an {@link IndexInput}. **/
 public final class MemorySegmentES92Int7VectorsScorer extends MemorySegmentES92PanamaInt7VectorsScorer {
 
-    public MemorySegmentES92Int7VectorsScorer(IndexInput in, int dimensions, int bulkSize, MemorySegment memorySegment) {
-        super(in, dimensions, bulkSize, memorySegment);
+    public MemorySegmentES92Int7VectorsScorer(IndexInput in, int dimensions, int bulkSize) {
+        super(in, dimensions, bulkSize);
     }
 
     @Override