cache validated FLASHDeconv exe paths to skip per-scan syscalls

  Each Deconvoluter.Deconvolute(scan, params) call constructs a fresh
  RealFLASHDeconvolutionAlgorithm and runs ResolveExePath, which hits
  File.Exists on the explicit path -- or walks the well-known list and
  PATH on misses. On a per-scan loop that's redundant filesystem syscalls
  per minute; the exe doesn't move between calls.

  - New public FlashDeconvExePathRegistry static class (ConcurrentDictionary
    of validated paths) with a Register(path) entry point. Production
    callers (e.g. MetaMorpheus from GlobalSettings.FLASHDeconvExecutablePath)
    can prime the registry once at startup so every Deconvolute call
    becomes lookup-only. Ad-hoc callers don't have to do anything --
    ResolveExePath caches lazily on first miss either way.

  - ResolveExePath now consults the registry first; on miss, runs the
    existing validate-and-resolve and caches the result. The 3-arg
    internal overload used by tests for deterministic injection is
    unchanged -- rubric tests stay isolated from cache state.

  - Cache key is the explicit path string, or a sentinel for the null
    default-search case. ConcurrentDictionary for thread-safety across
    parallel deconvolutions.

  - Cache invalidation is 'never' by design: the cached 'validated' state
    is an optimization, not a correctness contract. If the exe gets
    deleted at runtime, Process.Start surfaces the failure with the same
    error, just deferred. Internal Clear() exists only for test isolation.

  - 4 new tests in section E0 of TestRealFLASHDeconvolutionInfrastructure:
    Register valid / missing / null-or-empty inputs, plus an end-to-end
    test that registers a path, deletes the file, and asserts Deconvolute
    still proceeds (proves the cache is consulted, not the live filesystem).

Author: trishorts

mzLib/MassSpectrometry/Deconvolution/Algorithms/FlashDeconvExePathRegistry.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+
+namespace MassSpectrometry
+{
+    /// <summary>
+    /// Static registry of validated FLASHDeconv executable paths.
+    ///
+    /// Each <see cref="Deconvoluter.Deconvolute(MzSpectrum, DeconvolutionParameters, MzLibUtil.MzRange)"/>
+    /// call constructs a fresh <see cref="RealFLASHDeconvolutionAlgorithm"/>, and
+    /// resolving the FLASHDeconv exe path costs File.Exists syscalls (the explicit
+    /// path, plus a walk of well-known paths and the PATH env var on misses).
+    /// On a per-scan hot path that's a few-hundred-ms stack of redundant syscalls
+    /// per minute. The exe doesn't move between calls, so first-call validation
+    /// is enough -- this registry caches the resolved path so subsequent calls
+    /// skip the filesystem.
+    ///
+    /// Production callers that know the path up front (typically MetaMorpheus via
+    /// <c>GlobalSettings.FLASHDeconvExecutablePath</c>) should call
+    /// <see cref="Register"/> once at startup. Ad-hoc callers don't have to do
+    /// anything: the algorithm caches lazily on first resolution either way.
+    /// </summary>
+    public static class FlashDeconvExePathRegistry
+    {
+        // Sentinel key for "no explicit path was supplied; this is the result of
+        // walking the well-known list + PATH". A real path string can never collide
+        // with this because the inner '<' / '>' aren't legal in filesystem paths.
+        internal const string DefaultSearchSentinel = "<default-search>";
+
+        private static readonly ConcurrentDictionary<string, string> _validated
+            = new ConcurrentDictionary<string, string>();
+
+        /// <summary>
+        /// Validate the given exe path once and cache it so subsequent
+        /// deconvolution calls skip the filesystem check.
+        /// </summary>
+        /// <exception cref="ArgumentException">path is null/whitespace.</exception>
+        /// <exception cref="FileNotFoundException">path does not exist on disk.</exception>
+        public static void Register(string path)
+        {
+            if (string.IsNullOrWhiteSpace(path))
+                throw new ArgumentException("Path must be a non-empty string.", nameof(path));
+            if (!File.Exists(path))
+                throw new FileNotFoundException(
+                    $"FLASHDeconv not found at: {path}", path);
+            _validated[path] = path;
+        }
+
+        /// <summary>
+        /// Number of entries currently cached. Useful for tests that want to
+        /// assert registration happened without depending on internal state.
+        /// </summary>
+        public static int Count => _validated.Count;
+
+        /// <summary>
+        /// Forget every cached path. Test-only -- production code has no reason
+        /// to clear because validation is permissive (a stale cached entry just
+        /// pushes the actual existence check to Process.Start, which surfaces
+        /// the same failure with a clear error).
+        /// </summary>
+        internal static void Clear() => _validated.Clear();
+
+        /// <summary>
+        /// Look up a previously-validated resolution. Key is the explicit path
+        /// string, or the default-search sentinel when <paramref name="explicitPath"/>
+        /// is null/whitespace (i.e. the caller wants the algorithm to search
+        /// well-known paths + PATH itself).
+        /// </summary>
+        internal static bool TryGet(string? explicitPath, out string resolved)
+        {
+            string key = string.IsNullOrWhiteSpace(explicitPath)
+                ? DefaultSearchSentinel
+                : explicitPath!;
+            return _validated.TryGetValue(key, out resolved!);
+        }
+
+        /// <summary>
+        /// Cache a resolution that has already been validated (typically by the
+        /// algorithm's own resolve pass). Keyed identically to
+        /// <see cref="TryGet"/>: explicit path or default-search sentinel.
+        /// </summary>
+        internal static void CacheValidated(string? explicitPath, string resolved)
+        {
+            string key = string.IsNullOrWhiteSpace(explicitPath)
+                ? DefaultSearchSentinel
+                : explicitPath!;
+            _validated[key] = resolved;
+        }
+    }
+}

mzLib/MassSpectrometry/Deconvolution/Algorithms/RealFLASHDeconvolutionAlgorithm.cs

@@ -173,12 +173,31 @@ internal static Dictionary<int, List<IsotopicEnvelope>> DeconvoluteFile(
 
         // ── Exe resolution ────────────────────────────────────────────────────
 
+        /// <summary>
+        /// Production-side resolver: consult the static registry first; on miss,
+        /// run the full validate-and-resolve pass and cache the result so the
+        /// next per-scan call skips the filesystem.
+        ///
+        /// MetaMorpheus / other consumers can prime the registry up front via
+        /// <see cref="FlashDeconvExePathRegistry.Register"/>, in which case this
+        /// method becomes a single dictionary lookup per call.
+        /// </summary>
         private static string ResolveExePath(string? explicitPath)
-            => ResolveExePath(
+        {
+            if (FlashDeconvExePathRegistry.TryGet(explicitPath, out string cached))
+                return cached;
+
+            string resolved = ResolveExePath(
                 explicitPath,
                 DefaultWellKnownPaths,
                 Environment.GetEnvironmentVariable("PATH"));
 
+            // The inner overload already verified File.Exists during the resolve;
+            // store the result so the next call doesn't re-check.
+            FlashDeconvExePathRegistry.CacheValidated(explicitPath, resolved);
+            return resolved;
+        }
+
         /// <summary>
         /// Test-friendly overload that takes the well-known-paths list and PATH-env
         /// value as parameters instead of reading them from compiled-in defaults +

mzLib/Test/Deconvolution/TestRealFLASHDeconvolutionInfrastructure.cs

@@ -598,6 +598,89 @@ public void ParseSpecTsvByScan_RowsWithUnparseableRequiredCells_AreSilentlySkipp
             }
         }
 
+        // ── E0: FlashDeconvExePathRegistry (caching layer) ────────────────────
+
+        [Test]
+        public void FlashDeconvExePathRegistry_RegisterValidPath_AddsEntryAndCounts()
+        {
+            FlashDeconvExePathRegistry.Clear();
+            string fake = CreateFakeExeFile();
+            try
+            {
+                Assert.That(FlashDeconvExePathRegistry.Count, Is.EqualTo(0));
+                FlashDeconvExePathRegistry.Register(fake);
+                Assert.That(FlashDeconvExePathRegistry.Count, Is.EqualTo(1));
+            }
+            finally
+            {
+                FlashDeconvExePathRegistry.Clear();
+                if (File.Exists(fake)) File.Delete(fake);
+            }
+        }
+
+        [Test]
+        public void FlashDeconvExePathRegistry_RegisterMissingPath_ThrowsFileNotFound()
+        {
+            FlashDeconvExePathRegistry.Clear();
+            string nonexistent = Path.Combine(Path.GetTempPath(),
+                $"realflash_missing_{Guid.NewGuid():N}.exe");
+
+            Assert.That(
+                () => FlashDeconvExePathRegistry.Register(nonexistent),
+                Throws.TypeOf<FileNotFoundException>());
+            Assert.That(FlashDeconvExePathRegistry.Count, Is.EqualTo(0),
+                "Failed registration must not leak a partial entry into the registry.");
+        }
+
+        [Test]
+        public void FlashDeconvExePathRegistry_RegisterNullOrEmpty_ThrowsArgumentException()
+        {
+            Assert.That(() => FlashDeconvExePathRegistry.Register(null!),
+                Throws.TypeOf<ArgumentException>());
+            Assert.That(() => FlashDeconvExePathRegistry.Register(""),
+                Throws.TypeOf<ArgumentException>());
+            Assert.That(() => FlashDeconvExePathRegistry.Register("   "),
+                Throws.TypeOf<ArgumentException>());
+        }
+
+        [Test]
+        public void Deconvolute_WithRegisteredPath_SkipsFilesystemValidation()
+        {
+            // Pin the optimization: once a path is in the registry, the algorithm
+            // uses it without re-checking File.Exists. Prove the cache is being
+            // consulted by registering the path, deleting the file, and observing
+            // that Deconvolute still proceeds to the stub runner -- a non-cached
+            // resolve would throw FileNotFoundException at this point.
+            FlashDeconvExePathRegistry.Clear();
+            string fakeExe = CreateFakeExeFile();
+            FlashDeconvExePathRegistry.Register(fakeExe);
+            File.Delete(fakeExe);  // cache says it exists; filesystem says otherwise
+
+            try
+            {
+                var p = new RealFLASHDeconvolutionParameters(
+                    flashDeconvExePath: fakeExe,
+                    minMass: 50, maxMass: 5000);
+
+                string tsv = string.Join("\n",
+                    Ms1TsvHeader,
+                    "1\t1000.0\t5.0e5\t5\t201.0\t201.4\t0.95\t12.0\t0.8");
+
+                var algorithm = new RealFLASHDeconvolutionAlgorithm(p, BuildStubRunner(tsv));
+
+                var result = algorithm
+                    .Deconvolute(BuildSyntheticSpectrum(), new MzRange(0, 5000))
+                    .ToList();
+
+                Assert.That(result, Has.Count.EqualTo(1),
+                    "Cached path must be honored without re-validating that the file still exists; the deleted file would otherwise throw before the stub runner runs.");
+            }
+            finally
+            {
+                FlashDeconvExePathRegistry.Clear();
+            }
+        }
+
         // ── E: ResolveExePath unit tests ──────────────────────────────────────
 
         [Test]