Refactor GroupVIntUtil functional interface lambda which does not inline correctly in MemorySegmentIndexInput (#15089)

Refactor GroupVIntUtil functional interface lambda which does not inline correctly in MemorySegmentIndexInput.
This (hopefully) fixes #15079

Author: uschindler

lucene/CHANGES.txt

@@ -166,6 +166,9 @@ Improvements
 
 * GITHUB#14816: Expose search strategy in KNN query
 
+* GITHUB#15089, GITHUB#15079: Refactor GroupVIntUtil functional interface lambda
+  which does not inline correctly in MemorySegmentIndexInput (Uwe Schindler, Robert Muir)
+
 Optimizations
 ---------------------
 * GITHUB#14932: Switched to GroupVarInt Encoding for HNSW Graph edges, added backwards compatibility (Akira Lonske)

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

@@ -154,7 +154,13 @@ public final int readInt() throws IOException {
   public void readGroupVInt(int[] dst, int offset) throws IOException {
     final int len =
         GroupVIntUtil.readGroupVInt(
-            this, buffer.remaining(), p -> buffer.getInt((int) p), buffer.position(), dst, offset);
+            this,
+            buffer.remaining(),
+            GroupVIntUtil.VH_BUFFER_GET_INT,
+            buffer,
+            buffer.position(),
+            dst,
+            offset);
     if (len > 0) {
       buffer.position(buffer.position() + len);
     }

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

@@ -38,6 +38,7 @@
  */
 public final class ByteBuffersDataInput extends DataInput
     implements Accountable, RandomAccessInput {
+
   private final ByteBuffer[] blocks;
   private final FloatBuffer[] floatBuffers;
   private final LongBuffer[] longBuffers;
@@ -215,7 +216,8 @@ public void readGroupVInt(int[] dst, int offset) throws IOException {
         GroupVIntUtil.readGroupVInt(
             this,
             block.limit() - blockOffset,
-            p -> block.getInt((int) p),
+            GroupVIntUtil.VH_BUFFER_GET_INT,
+            block,
             blockOffset,
             dst,
             offset);

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

@@ -23,6 +23,9 @@
 import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.ValueLayout;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
 import java.nio.ByteOrder;
 import java.util.Arrays;
 import java.util.Objects;
@@ -52,6 +55,13 @@ abstract class MemorySegmentIndexInput extends IndexInput implements MemorySegme
       ValueLayout.JAVA_FLOAT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
   private static final Optional<NativeAccess> NATIVE_ACCESS = NativeAccess.getImplementation();
 
+  private static final VarHandle VH_MEMSEG_GET_INT =
+      MethodHandles.filterCoordinates(
+          LAYOUT_LE_INT.varHandle(),
+          0,
+          MethodHandles.identity(Object.class)
+              .asType(MethodType.methodType(MemorySegment.class, Object.class)));
+
   final long length;
   final long chunkSizeMask;
   final int chunkSizePower;
@@ -454,7 +464,8 @@ public void readGroupVInt(int[] dst, int offset) throws IOException {
           GroupVIntUtil.readGroupVInt(
               this,
               curSegment.byteSize() - curPosition,
-              p -> curSegment.get(LAYOUT_LE_INT, p),
+              VH_MEMSEG_GET_INT,
+              curSegment,
               curPosition,
               dst,
               offset);

lucene/core/src/java/org/apache/lucene/util/GroupVIntUtil.java

@@ -17,6 +17,11 @@
 package org.apache.lucene.util;
 
 import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import org.apache.lucene.store.DataInput;
 import org.apache.lucene.store.DataOutput;
 
@@ -33,6 +38,23 @@ public final class GroupVIntUtil {
   private static final long[] LONG_MASKS = new long[] {0xFFL, 0xFFFFL, 0xFFFFFFL, 0xFFFFFFFFL};
   private static final int[] INT_MASKS = new int[] {0xFF, 0xFFFF, 0xFFFFFF, ~0};
 
+  /**
+   * A {@link VarHandle} which allows to read ints from a {@link ByteBuffer} using {@code long}
+   * offsets. The handle can be used with the {@code readGroupVInt()} methods taking a {@code
+   * VarHandle} and {@code ByteBuffer} storage parameter.
+   *
+   * @see #readGroupVInt(DataInput, long, VarHandle, Object, long, int[], int)
+   * @see #readGroupVInt(DataInput, long, VarHandle, Object, long, long[], int)
+   */
+  public static final VarHandle VH_BUFFER_GET_INT =
+      MethodHandles.filterCoordinates(
+          MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN),
+          0,
+          MethodHandles.identity(Object.class)
+              .asType(MethodType.methodType(ByteBuffer.class, Object.class)),
+          MethodHandles.explicitCastArguments(
+              MethodHandles.identity(long.class), MethodType.methodType(int.class, long.class)));
+
   /**
    * Read all the group varints, including the tail vints. we need a long[] because this is what
    * postings are using, all longs are actually required to be integers.
@@ -126,21 +148,15 @@ private static int readIntInGroup(DataInput in, int numBytesMinus1) throws IOExc
   }
 
   /**
-   * Provides an abstraction for read int values, so that decoding logic can be reused in different
-   * DataInput.
-   */
-  @FunctionalInterface
-  public static interface IntReader {
-    int read(long v);
-  }
-
-  /**
-   * Faster implementation of read single group, It read values from the buffer that would not cross
-   * boundaries.
+   * Faster implementation of read single group, It read values from {@link VarHandle} that would
+   * not cross boundaries.
    *
    * @param in the input to use to read data.
    * @param remaining the number of remaining bytes allowed to read for current block/segment.
-   * @param reader the supplier of read int.
+   * @param vh the varhandle which has the coordinates {@code (Object, long)}. The first coordinate
+   *     must accept the {@code storage} parameter, the second coordinate must be the long offset.
+   * @param storage the reference to the backing storage (e.g., one of {@code byte[], ByteBuffer,
+   *     MemorySegment})
    * @param pos the start pos to read from the reader.
    * @param dst the array to read ints into.
    * @param offset the offset in the array to start storing ints.
@@ -149,7 +165,7 @@ public static interface IntReader {
    *     #MAX_LENGTH_PER_GROUP}
    */
   public static int readGroupVInt(
-      DataInput in, long remaining, IntReader reader, long pos, long[] dst, int offset)
+      DataInput in, long remaining, VarHandle vh, Object storage, long pos, long[] dst, int offset)
       throws IOException {
     if (remaining < MAX_LENGTH_PER_GROUP) {
       readGroupVInt(in, dst, offset);
@@ -163,24 +179,27 @@ public static int readGroupVInt(
     final int n4Minus1 = flag & 0x03;
 
     // This code path has fewer conditionals and tends to be significantly faster in benchmarks
-    dst[offset] = reader.read(pos) & LONG_MASKS[n1Minus1];
+    dst[offset] = (int) vh.get(storage, pos) & LONG_MASKS[n1Minus1];
     pos += 1 + n1Minus1;
-    dst[offset + 1] = reader.read(pos) & LONG_MASKS[n2Minus1];
+    dst[offset + 1] = (int) vh.get(storage, pos) & LONG_MASKS[n2Minus1];
     pos += 1 + n2Minus1;
-    dst[offset + 2] = reader.read(pos) & LONG_MASKS[n3Minus1];
+    dst[offset + 2] = (int) vh.get(storage, pos) & LONG_MASKS[n3Minus1];
     pos += 1 + n3Minus1;
-    dst[offset + 3] = reader.read(pos) & LONG_MASKS[n4Minus1];
+    dst[offset + 3] = (int) vh.get(storage, pos) & LONG_MASKS[n4Minus1];
     pos += 1 + n4Minus1;
     return (int) (pos - posStart);
   }
 
   /**
-   * Faster implementation of read single group, It read values from the buffer that would not cross
-   * boundaries.
+   * Faster implementation of read single group, It read values from a {@link VarHandle} that would
+   * not cross boundaries.
    *
    * @param in the input to use to read data.
    * @param remaining the number of remaining bytes allowed to read for current block/segment.
-   * @param reader the supplier of read int.
+   * @param vh the varhandle which has the coordinates {@code (Object, long)}. The first coordinate
+   *     must accept the {@code storage} parameter, the second coordinate must be the long offset.
+   * @param storage the reference to the backing storage (e.g., one of {@code byte[], ByteBuffer,
+   *     MemorySegment})
    * @param pos the start pos to read from the reader.
    * @param dst the array to read ints into.
    * @param offset the offset in the array to start storing ints.
@@ -189,7 +208,7 @@ public static int readGroupVInt(
    *     #MAX_LENGTH_PER_GROUP}
    */
   public static int readGroupVInt(
-      DataInput in, long remaining, IntReader reader, long pos, int[] dst, int offset)
+      DataInput in, long remaining, VarHandle vh, Object storage, long pos, int[] dst, int offset)
       throws IOException {
     if (remaining < MAX_LENGTH_PER_GROUP) {
       readGroupVInt(in, dst, offset);
@@ -203,13 +222,13 @@ public static int readGroupVInt(
     final int n4Minus1 = flag & 0x03;
 
     // This code path has fewer conditionals and tends to be significantly faster in benchmarks
-    dst[offset] = reader.read(pos) & INT_MASKS[n1Minus1];
+    dst[offset] = (int) vh.get(storage, pos) & INT_MASKS[n1Minus1];
     pos += 1 + n1Minus1;
-    dst[offset + 1] = reader.read(pos) & INT_MASKS[n2Minus1];
+    dst[offset + 1] = (int) vh.get(storage, pos) & INT_MASKS[n2Minus1];
     pos += 1 + n2Minus1;
-    dst[offset + 2] = reader.read(pos) & INT_MASKS[n3Minus1];
+    dst[offset + 2] = (int) vh.get(storage, pos) & INT_MASKS[n3Minus1];
     pos += 1 + n3Minus1;
-    dst[offset + 3] = reader.read(pos) & INT_MASKS[n4Minus1];
+    dst[offset + 3] = (int) vh.get(storage, pos) & INT_MASKS[n4Minus1];
     pos += 1 + n4Minus1;
     return (int) (pos - posStart);
   }