Pass capacity: 0 to MemoryMappedFile.CreateFromFile, drop the #1090 retry loop

MemoryMappedFile.CreateFromFile accepts capacity: 0 to mean "size the
mapping from the file's current length on disk." The framework does its
own stat as part of the mapping creation, so there is no caller-side
capacity for the file size to disagree with — the race window that
#1090 was about is closed at the API boundary.

This also lets us drop the FileStream we were holding alongside
SharedMapping. The only thing it was being used for was capturing
fc.Length to feed into our retry loop, plus being kept alive so the
mapping had a handle. The path-based CreateFromFile overload opens
its own handle and disposes it with the MemoryMappedFile, so we no
longer need our own.

Removes the retry loop in CreateMemoryMappedFile, the s_capacityRetryCount
and s_maxCapacityAttemptsObserved test-observability counters, and the
fileStream field on SharedMapping.

Rewrites TestOpenInputConcurrentFileExtension_Issue1090 from a "race
fired and was retried" assertion into a "OpenInput succeeds under
concurrent file extension" smoke test. With capacity: 0 the original
race no longer reaches the framework, so 8700 OpenInput iterations
over 15s observed zero retries before the change. The test now
shortens to a 5s window and simply asserts that every OpenInput
completes cleanly while another thread extends/truncates the file.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net.Tests/Store/TestMultiMMap.cs

@@ -496,16 +496,17 @@ private void AssertChunking(Random random, int chunkSize)
 
         // LUCENENET: Regression test for GitHub #1090. A background thread
         // extends a file on disk while the foreground thread repeatedly
-        // opens it with MMapDirectory.OpenInput. Before the fix, the
-        // file's length could grow between the caller capturing fc.Length
-        // and MemoryMappedFile.CreateFromFile performing its internal
-        // stat, causing ArgumentOutOfRangeException (paramName="capacity")
-        // with the message "The capacity may not be smaller than the
-        // file size."
-        // NonParallelizable: the retry-path assertion reads static counters on
-        // MMapDirectory, so any other test exercising MMapDirectory in parallel
-        // could skew the observed retry count.
-        [Test, LuceneNetSpecific, Slow, NonParallelizable]
+        // opens it with MMapDirectory.OpenInput. The original failure
+        // mode was ArgumentOutOfRangeException(paramName="capacity")
+        // from MemoryMappedFile.CreateFromFile, because we were passing
+        // a caller-computed capacity (fc.Length) that could be smaller
+        // than the actual file size by the time the framework did its
+        // internal stat. The current design passes capacity: 0, which
+        // tells the framework to size the mapping from the file's
+        // current on-disk length atomically — there is no caller-side
+        // capacity to disagree with the file. This test asserts that
+        // OpenInput continues to succeed under concurrent file extension.
+        [Test, LuceneNetSpecific, Slow]
         public void TestOpenInputConcurrentFileExtension_Issue1090()
         {
             var dir = CreateTempDir("testOpenInputConcurrentFileExtension");
@@ -549,50 +550,25 @@ public void TestOpenInputConcurrentFileExtension_Issue1090()
             { IsBackground = true, Name = "mmap-issue1090-extender" };
             writer.Start();
 
-            // Snapshot counters so this test's assertion is not affected by
-            // any earlier test's activity on MMapDirectory.
-            long baselineRetries = Interlocked.Read(ref MMapDirectory.s_capacityRetryCount);
-
             try
             {
                 var sw = Stopwatch.StartNew();
                 int iterations = 0;
-                // Keep stretching the window until either the race fires or we
-                // hit a hard deadline. On most machines this takes < 1 second.
-                const int maxSeconds = 15;
+                // Stress OpenInput while the background thread extends/truncates the
+                // file. Each call must succeed cleanly. A short window is plenty:
+                // before the capacity:0 fix this race fired in well under a second.
+                const int maxSeconds = 5;
                 while (sw.Elapsed < TimeSpan.FromSeconds(maxSeconds))
                 {
                     using (var _ = mmapDir.OpenInput(name, NewIOContext(Random)))
                     {
-                        // Just open and dispose; the race occurs during construction.
+                        // Just open and dispose; the race occurred during construction.
                     }
                     iterations++;
-
-                    if (Interlocked.Read(ref MMapDirectory.s_capacityRetryCount) > baselineRetries)
-                    {
-                        break; // race reproduced and handled by the retry loop
-                    }
                 }
 
-                long retries = Interlocked.Read(ref MMapDirectory.s_capacityRetryCount) - baselineRetries;
-                int maxAttempts = Volatile.Read(ref MMapDirectory.s_maxCapacityAttemptsObserved);
-
-                // Surface what was observed for diagnostics when run with -v normal.
                 TestContext.Progress.WriteLine(
-                    $"TestOpenInputConcurrentFileExtension: iterations={iterations}, retries={retries}, maxAttemptsObserved={maxAttempts}");
-
-                // The real check: the race must have fired and our retry loop
-                // must have swallowed it. Without the fix, the exception
-                // escapes OpenInput and the test fails with ArgumentOutOfRangeException
-                // (as seen in #1090). If the race never fires during this run
-                // (timing-dependent), mark the test inconclusive rather than
-                // silently passing — we haven't actually exercised the fix.
-                if (retries == 0)
-                {
-                    NUnit.Framework.Assert.Inconclusive(
-                        $"The concurrent-extension race was not reproduced within {maxSeconds}s " +
-                        $"({iterations} OpenInput iterations). The fix was therefore not exercised on this run.");
-                }
+                    $"TestOpenInputConcurrentFileExtension: completed {iterations} OpenInput calls in {sw.Elapsed.TotalSeconds:F1}s");
             }
             finally
             {

src/Lucene.Net/Store/MMapDirectory.cs

@@ -66,14 +66,6 @@ public class MMapDirectory : FSDirectory
 
         private readonly int chunkSizePower;
 
-        // LUCENENET specific: test-only counters for the capacity-retry
-        // path in Map() — see #1090. Internal (exposed via InternalsVisibleTo
-        // to the test assemblies) so regression tests can assert that the
-        // race was actually exercised during a run, and to gather data on how
-        // many retries are typically needed. Not intended for production use.
-        internal static long s_capacityRetryCount;
-        internal static int s_maxCapacityAttemptsObserved;
-
         /// <summary>
         /// Create a new <see cref="MMapDirectory"/> for the named location.
         /// </summary>
@@ -762,38 +754,55 @@ internal sealed unsafe class SharedMapping : IDisposable
             /// Note that this can be null in the edge case of a zero-length mapping.
             /// </summary>
             private readonly MemoryMappedFile? memoryMappedFile;
-            private readonly FileStream fileStream;
             private int disposed;
 
-            private SharedMapping(MemoryMappedFile? mmf, FileStream fs, Chunk[] chunks, long length)
+            private SharedMapping(MemoryMappedFile? mmf, Chunk[] chunks, long length)
             {
                 this.memoryMappedFile = mmf;
-                this.fileStream = fs;
                 this.Chunks = chunks;
                 this.Length = length;
             }
 
             internal static SharedMapping Create(string file, int chunkSizePower)
             {
-                // MemoryMappedFile uses only the file handle and bypasses
-                // the FileStream buffer, so bufferSize: 1 avoids allocating
-                // a 4 KiB buffer that would immediately be discarded.
-                var fs = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite,
-                    bufferSize: 1, FileOptions.RandomAccess | FileOptions.Asynchronous);
+                // We don't track a separate FileStream: the path-based
+                // CreateFromFile overload opens its own handle and
+                // disposes it with the MemoryMappedFile. We capture the
+                // file length once via FileInfo for our own snapshot
+                // (used as the slice/range upper bound). Any divergence
+                // between this snapshot and the framework's internal
+                // stat — e.g. the file growing in between, formerly the
+                // #1090 race — is harmless: the mmap itself is sized by
+                // the framework's own stat, and our `length` is treated
+                // as a snapshot at open time (matching upstream Java's
+                // fc.size() snapshot semantics).
+                long length = new FileInfo(file).Length;
+                if (length == 0)
+                {
+                    return new SharedMapping(mmf: null, chunks: Array.Empty<Chunk>(), length: 0);
+                }
+
                 MemoryMappedFile? mmf = null;
                 Chunk[]? chunks = null;
                 try
                 {
-                    long length = fs.Length;
-                    mmf = CreateMemoryMappedFile(fs, length);
+                    // capacity: 0 -> the framework uses the file's
+                    // current size on disk, atomically with mapping
+                    // creation. This eliminates the #1090 race window
+                    // we previously had to retry around.
+                    mmf = MemoryMappedFile.CreateFromFile(
+                        path: file,
+                        mode: FileMode.Open,
+                        mapName: null,
+                        capacity: 0,
+                        access: MemoryMappedFileAccess.Read);
                     chunks = MapChunks(mmf, 0, length, chunkSizePower);
-                    return new SharedMapping(mmf, fs, chunks, length);
+                    return new SharedMapping(mmf, chunks, length);
                 }
                 catch
                 {
                     DisposeChunks(chunks);
                     mmf?.Dispose();
-                    IOUtils.DisposeWhileHandlingException(fs);
                     throw;
                 }
             }
@@ -805,63 +814,13 @@ public void Dispose()
             {
                 if (Interlocked.CompareExchange(ref disposed, 1, 0) != 0) return;
                 DisposeChunks(Chunks);
-                IOUtils.DisposeWhileHandlingException(memoryMappedFile, fileStream);
+                IOUtils.DisposeWhileHandlingException(memoryMappedFile);
             }
 
             internal Chunk[] Chunks { get; }
 
             internal long Length { get; }
 
-            private static MemoryMappedFile? CreateMemoryMappedFile(FileStream fc, long requiredCapacity)
-            {
-                if (requiredCapacity <= 0)
-                {
-                    return null;
-                }
-
-                // LUCENENET specific BEGIN: retry on capacity race (#1090).
-                // MemoryMappedFile.CreateFromFile performs an internal stat
-                // and throws ArgumentOutOfRangeException("capacity") if the
-                // on-disk file size exceeds the requested capacity. When
-                // another process/thread is appending to this file, the file
-                // can grow between when we capture fc.Length and when
-                // CreateFromFile reads the size.
-                long capacity = Math.Max(requiredCapacity, fc.Length);
-                const int maxAttempts = 5;
-                int attempt = 0;
-                while (true)
-                {
-                    try
-                    {
-                        var mmf = MemoryMappedFile.CreateFromFile(
-                            fileStream: fc,
-                            mapName: null,
-                            capacity: capacity,
-                            access: MemoryMappedFileAccess.Read,
-#if FEATURE_MEMORYMAPPEDFILESECURITY
-                            memoryMappedFileSecurity: null,
-#endif
-                            inheritability: HandleInheritability.Inheritable,
-                            leaveOpen: true); // We dispose the FileStream explicitly.
-                        int attemptsTaken = attempt + 1;
-                        int prior;
-                        do
-                        {
-                            prior = Volatile.Read(ref s_maxCapacityAttemptsObserved);
-                            if (attemptsTaken <= prior) break;
-                        } while (Interlocked.CompareExchange(ref s_maxCapacityAttemptsObserved, attemptsTaken, prior) != prior);
-                        return mmf;
-                    }
-                    catch (ArgumentOutOfRangeException e) when (e.ParamName == "capacity" && attempt < maxAttempts - 1)
-                    {
-                        Interlocked.Increment(ref s_capacityRetryCount);
-                        capacity = Math.Max(capacity, fc.Length);
-                        attempt++;
-                    }
-                }
-                // LUCENENET specific END
-            }
-
             private static Chunk[] MapChunks(MemoryMappedFile? mmf, long offset, long length, int chunkSizePower)
             {
                 if (length == 0 || mmf == null)