Add support for posix_madvise to Java 21 MMapDirectory

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

@@ -23,12 +23,20 @@
 import java.nio.channels.FileChannel.MapMode;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
+import java.util.OptionalInt;
+import org.apache.lucene.store.IOContext.Context;
 import org.apache.lucene.util.Constants;
 import org.apache.lucene.util.Unwrappable;
 
 @SuppressWarnings("preview")
 final class MemorySegmentIndexInputProvider implements MMapDirectory.MMapIndexInputProvider {
 
+  private final NativeAccess nativeAccess;
+
+  MemorySegmentIndexInputProvider() {
+    this.nativeAccess = NativeAccess.getImplementation();
+  }
+
   @Override
   public IndexInput openInput(Path path, IOContext context, int chunkSizePower, boolean preload)
       throws IOException {
@@ -45,7 +53,7 @@ public IndexInput openInput(Path path, IOContext context, int chunkSizePower, bo
           MemorySegmentIndexInput.newInstance(
               resourceDescription,
               arena,
-              map(arena, resourceDescription, fc, chunkSizePower, preload, fileSize),
+              map(arena, resourceDescription, fc, context, chunkSizePower, preload, fileSize),
               fileSize,
               chunkSizePower);
       success = true;
@@ -66,12 +74,22 @@ private final MemorySegment[] map(
       Arena arena,
       String resourceDescription,
       FileChannel fc,
+      IOContext context,
       int chunkSizePower,
       boolean preload,
       long length)
       throws IOException {
-    if ((length >>> chunkSizePower) >= Integer.MAX_VALUE)
+    if ((length >>> chunkSizePower) >= Integer.MAX_VALUE) {
       throw new IllegalArgumentException("File too big for chunk size: " + resourceDescription);
+    }
+
+    final OptionalInt advice;
+    if (chunkSizePower < 21) {
+      // if chunk size is too small (2 MiB), disable madvise support (incorrect alignment):
+      advice = OptionalInt.empty();
+    } else {
+      advice = mapContextToMadvise(context);
+    }
 
     final long chunkSize = 1L << chunkSizePower;
 
@@ -92,10 +110,19 @@ private final MemorySegment[] map(
       }
       if (preload) {
         segment.load();
+      } else if (segSize > 0L && advice.isPresent()) { // not when preloading!
+        nativeAccess.madvise(segment, advice.getAsInt());
       }
       segments[segNr] = segment;
       startOffset += segSize;
     }
     return segments;
   }
+
+  private OptionalInt mapContextToMadvise(IOContext context) {
+    if (context.readOnce || context.context == Context.MERGE) {
+      return OptionalInt.of(NativeAccess.POSIX_MADV_SEQUENTIAL);
+    }
+    return OptionalInt.empty();
+  }
 }

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

@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.store;
+
+import java.io.IOException;
+import java.lang.foreign.MemorySegment;
+import java.util.Locale;
+import java.util.logging.Logger;
+import org.apache.lucene.util.Constants;
+
+@SuppressWarnings("preview")
+abstract class NativeAccess {
+  private static final Logger LOG = Logger.getLogger(NativeAccess.class.getName());
+
+  // these constants were extracted from glibc and macos header files - luckily they are the same:
+
+  /** No further special treatment. */
+  public static final int POSIX_MADV_NORMAL = 0;
+
+  /** Expect random page references. */
+  public static final int POSIX_MADV_RANDOM = 1;
+
+  /** Expect sequential page references. */
+  public static final int POSIX_MADV_SEQUENTIAL = 2;
+
+  /** Will need these pages. */
+  public static final int POSIX_MADV_WILLNEED = 3;
+
+  /** Don't need these pages. */
+  public static final int POSIX_MADV_DONTNEED = 4;
+
+  /** Invoke the {@code madvise} call for the given {@link MemorySegment}. */
+  public abstract void madvise(MemorySegment segment, int advice) throws IOException;
+
+  /**
+   * Return the NativeAccess instance for this platform. At moment we only support Linux and MacOS
+   */
+  public static NativeAccess getImplementation() {
+    if (Constants.LINUX || Constants.MAC_OS_X) {
+      try {
+        return new PosixNativeAccess();
+      } catch (UnsupportedOperationException uoe) {
+        LOG.warning(uoe.getMessage());
+      } catch (IllegalCallerException ice) {
+        LOG.warning(
+            String.format(
+                Locale.ENGLISH,
+                "Lucene has no access to native functions (%s). To enable access to native functions, "
+                    + "pass the following on command line: --enable-native-access=org.apache.lucene.core",
+                ice.getMessage()));
+      }
+    }
+    return new NoopNativeAccess();
+  }
+}

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

@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.store;
+
+import java.lang.foreign.MemorySegment;
+
+@SuppressWarnings("preview")
+final class NoopNativeAccess extends NativeAccess {
+
+  @Override
+  public void madvise(MemorySegment segment, int advice) {}
+}

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

@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.store;
+
+import java.io.IOException;
+import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.Linker;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.SymbolLookup;
+import java.lang.foreign.ValueLayout;
+import java.lang.invoke.MethodHandle;
+import java.util.Locale;
+import java.util.logging.Logger;
+
+@SuppressWarnings("preview")
+final class PosixNativeAccess extends NativeAccess {
+
+  private static final Logger LOG = Logger.getLogger(PosixNativeAccess.class.getName());
+
+  private final MethodHandle mh$posix_madvise;
+
+  public PosixNativeAccess() {
+    final Linker linker = Linker.nativeLinker();
+    final SymbolLookup stdlib = linker.defaultLookup();
+    this.mh$posix_madvise =
+        findFunction(
+            linker,
+            stdlib,
+            "posix_madvise",
+            FunctionDescriptor.of(
+                ValueLayout.JAVA_INT,
+                ValueLayout.ADDRESS,
+                ValueLayout.JAVA_LONG,
+                ValueLayout.JAVA_INT));
+    LOG.info("posix_madvise() available on this platform");
+  }
+
+  private static MethodHandle findFunction(
+      Linker linker, SymbolLookup lookup, String name, FunctionDescriptor desc) {
+    final MemorySegment symbol =
+        lookup
+            .find(name)
+            .orElseThrow(
+                () ->
+                    new UnsupportedOperationException(
+                        "Platform has no symbol for '" + name + "' in libc."));
+    return linker.downcallHandle(symbol, desc);
+  }
+
+  @Override
+  public void madvise(MemorySegment segment, int advice) throws IOException {
+    final int ret;
+    try {
+      ret = (int) mh$posix_madvise.invokeExact(segment, segment.byteSize(), advice);
+    } catch (Throwable th) {
+      throw new AssertionError(th);
+    }
+    if (ret != 0) {
+      throw new IOException(
+          String.format(
+              Locale.ENGLISH,
+              "Call to posix_madvise with address=0x%08X and byteSize=%d failed with return code %d.",
+              segment.address(),
+              segment.byteSize(),
+              ret));
+    }
+  }
+}