Checkpoint remaining concurrent runtime and test changes

Include the complete additional working-tree scope on main at the owner request. This is a source checkpoint; final solution and full functional qualification remain incomplete. The last root-verified canonical snapshot failed with 59 CS0103 errors; no passing build or full-suite acceptance is claimed for these concurrent edits.

Author: KSemenenko

Directory.Packages.props

@@ -18,6 +18,7 @@
     <PackageVersion Include="ManagedCode.MCPGateway" Version="0.4.17" />
     <PackageVersion Include="ManagedCode.MarkdownLd.Kb" Version="0.2.10" />
     <PackageVersion Include="Microsoft.Extensions.AI" Version="10.10.0" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="10.0.12" />
     <PackageVersion Include="Microsoft.Extensions.Options" Version="10.0.12" />
     <PackageVersion Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="10.0.12" />
     <PackageVersion Include="ModelContextProtocol.AspNetCore" Version="2.2.0" />

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Benchmarks/EmbeddedBenchmarks.cs

@@ -125,7 +125,7 @@ internal void Initialize(PartitionRef partition)
         {
             store = new(new(directory), options.Storage, options.PointCache);
             database = new(store, new AuthorizationPolicy(), options.Database, options.DueWork, options.EventSource,
-                options.Messaging);
+                options.Messaging, options.GraphExecution);
             database.Bootstrap(new(PrincipalId, PrincipalScope,
                 [new(Wildcard, Wildcard, Capability.All)], [Wildcard])
             { ClusterAdministrator = true },

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Configuration/EmbeddedBenchmarkRuntimeOptions.cs

@@ -9,7 +9,8 @@ namespace KeyLoad.BenchmarkScenarios.Features.BenchmarkComparisons;
 /// <summary>Holds the validated native snapshots borrowed by an embedded benchmark owner.</summary>
 internal sealed record EmbeddedBenchmarkRuntimeOptions(IOptions<DatabaseLimits> Database,
     IOptions<DueWorkExecutionOptions> DueWork, IOptions<EventSourceExecutionOptions> EventSource,
-    IOptions<MessagingExecutionOptions> Messaging, IOptions<ZoneTreeStorageExecutionOptions> Storage,
+    IOptions<MessagingExecutionOptions> Messaging, IOptions<GraphExecutionOptions> GraphExecution,
+    IOptions<ZoneTreeStorageExecutionOptions> Storage,
     IOptions<ZoneTreePointCacheExecutionOptions> PointCache);
 
 /// <summary>Binds the actual generated runner's environment to native fixture policies.</summary>
@@ -28,6 +29,8 @@ internal static EmbeddedBenchmarkRuntimeOptions Read()
                 settings => settings.IsValid(), EventSourceExecutionOptions.ValidationMessage),
             BenchmarkScenarioOptionsRegistration.Read<MessagingExecutionOptions>(configuration, MessagingExecutionOptions.SectionName,
                 settings => settings.IsValid(), MessagingExecutionOptions.ValidationMessage),
+            BenchmarkScenarioOptionsRegistration.Read<GraphExecutionOptions>(configuration, GraphExecutionOptions.SectionName,
+                settings => settings.IsValid(), GraphExecutionOptions.ValidationMessage),
             BenchmarkScenarioOptionsRegistration.Read<ZoneTreeStorageExecutionOptions>(configuration, ZoneTreeStorageExecutionOptions.SectionName,
                 settings => settings.IsValid(), ZoneTreeStorageExecutionOptions.ValidationMessage),
             BenchmarkScenarioOptionsRegistration.Read<ZoneTreePointCacheExecutionOptions>(configuration, ZoneTreePointCacheExecutionOptions.SectionName,

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Fixtures/ScaledStorage/ScaledRawStorageFixture.cs

@@ -1,27 +1,28 @@
 using System.Diagnostics;
+using Microsoft.Extensions.Options;
 using System.Runtime.ExceptionServices;
 
 namespace KeyLoad.BenchmarkScenarios.Features.BenchmarkComparisons;
 
 internal sealed class ScaledRawStorageFixture : IDisposable
 {
-    private const int PreparationLimitMinutes = 20;
-    internal static readonly TimeSpan PreparationLimit = TimeSpan.FromMinutes(PreparationLimitMinutes);
     private readonly CancellationTokenSource _lifetime;
     private ScaledRawStorageFixtureCore? _core;
     private bool _closing;
     private bool _disposed;
     private const string InactiveMessage = "The scaled native fixture is not initialized.";
     private const string DeadlineMessage = "The scaled fixture preparation deadline expired.";
 
-    internal ScaledRawStorageFixture(int recordCount, int payloadBytes,
+    internal ScaledRawStorageFixture(int recordCount, int payloadBytes, IOptions<ScaledStorageExecutionOptions> executionOptions,
         CancellationToken cancellationToken = default)
     {
+        var settings = executionOptions.Value;
+        settings.Validate();
         ScaledRawStorageSettings.ValidateInput(recordCount, payloadBytes);
         cancellationToken.ThrowIfCancellationRequested();
         var deadlineStart = Stopwatch.GetTimestamp();
-        var processMemoryCeiling = ScaledRawStorageSettings.ValidateFixtureCapacity(recordCount, payloadBytes);
-        var remaining = PreparationLimit - Stopwatch.GetElapsedTime(deadlineStart);
+        var processMemoryCeiling = ScaledRawStorageSettings.ValidateFixtureCapacity(recordCount, payloadBytes, settings);
+        var remaining = settings.PreparationTimeout - Stopwatch.GetElapsedTime(deadlineStart);
         if (remaining <= TimeSpan.Zero)
         {
             throw new TimeoutException(DeadlineMessage);
@@ -52,7 +53,7 @@ internal ScaledRawStorageFixture(int recordCount, int payloadBytes,
         try
         {
             _core = new ScaledRawStorageFixtureCore(recordCount, payloadBytes,
-                deadlineStart, processMemoryCeiling, _lifetime.Token);
+                deadlineStart, processMemoryCeiling, _lifetime.Token, executionOptions);
             _core.Initialize();
         }
         catch (Exception primary) when (RawStorageFixtureFailures.IsNonFatal(primary))

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Fixtures/ScaledStorage/ScaledRawStorageFixtureCore.cs

@@ -1,10 +1,13 @@
 using System.Diagnostics;
+using Microsoft.Extensions.Options;
 
 namespace KeyLoad.BenchmarkScenarios.Features.BenchmarkComparisons;
 
 internal sealed class ScaledRawStorageFixtureCore
 {
     private const string InitializedMessage = "The scaled fixture core initialization is one-shot.";
+    private readonly ScaledStorageExecutionOptions settings;
+    private readonly IOptions<ScaledStorageExecutionOptions> executionOptions;
     private readonly CancellationToken _token;
     private readonly long _deadlineStart;
     private readonly long _processMemoryCeilingBytes;
@@ -30,8 +33,10 @@ internal sealed class ScaledRawStorageFixtureCore
     private bool _disposed;
 
     internal ScaledRawStorageFixtureCore(int recordCount, int payloadBytes,
-        long deadlineStart, long processMemoryCeilingBytes, CancellationToken token)
+        long deadlineStart, long processMemoryCeilingBytes, CancellationToken token, IOptions<ScaledStorageExecutionOptions> executionOptions)
     {
+        settings = executionOptions.Value;
+        this.executionOptions = executionOptions;
         _token = token;
         _deadlineStart = deadlineStart;
         _processMemoryCeilingBytes = processMemoryCeilingBytes;
@@ -63,12 +68,12 @@ internal void Initialize()
         }
 
         _initializeStarted = true;
-        ScaledRawStoragePreparationGuard.Check(_deadlineStart, _token);
-        var engine = new ScaledRawStorageZoneTreeEngine(_corpus, _arena, _readScratch, _deadlineStart, _token);
+        ScaledRawStoragePreparationGuard.Check(_deadlineStart, _token, settings.PreparationTimeout);
+        var engine = new ScaledRawStorageZoneTreeEngine(_corpus, _arena, _readScratch, _deadlineStart, _token, executionOptions);
         _engine = engine;
         engine.Initialize();
         _seedElapsedTicks = ScaledRawStorageSeedRunner.Run(_corpus, engine, _seedScratch,
-            RecordCount, _deadlineStart, ref _seedAttempts, ref _successfulSeedWrites, _token);
+            RecordCount, _deadlineStart, ref _seedAttempts, ref _successfulSeedWrites, _token, settings.PreparationTimeout);
         VerifyAllCore(enforceBudget: true);
         _initialized = true;
     }
@@ -112,7 +117,7 @@ internal ScaledRawStorageSnapshot Capture()
         using var process = Process.GetCurrentProcess();
         var peak = ScaledRawStorageProcessMemory.ReadPeakBytes(process);
         var available = GC.GetGCMemoryInfo().TotalAvailableMemoryBytes;
-        ScaledRawStorageMemoryGuard.ValidateObserved(peak, available, _processMemoryCeilingBytes);
+        ScaledRawStorageMemoryGuard.ValidateObserved(peak, available, _processMemoryCeilingBytes, settings.RequiredHeadroomBytes);
         return ScaledRawStorageSnapshotFactory.Create(this, native, peak, process.WorkingSet64, available);
     }
 
@@ -175,16 +180,16 @@ private void VerifyAllCore(bool enforceBudget)
     {
         var result = ScaledRawStorageVerification.Run(_corpus, _engine!, _expectedScratch,
             RecordCount, ref _nativeReadCalls, enforceBudget ? _deadlineStart : 0L,
-            enforceBudget, enforceBudget ? _token : CancellationToken.None);
+            enforceBudget, enforceBudget ? _token : CancellationToken.None, settings.PreparationTimeout);
         _ = _engine!.Capture();
         if (enforceBudget)
         {
-            ScaledRawStoragePreparationGuard.Check(_deadlineStart, _token);
+            ScaledRawStoragePreparationGuard.Check(_deadlineStart, _token, settings.PreparationTimeout);
         }
 
         using var process = Process.GetCurrentProcess();
         ScaledRawStorageMemoryGuard.ValidateObserved(ScaledRawStorageProcessMemory.ReadPeakBytes(process),
-            GC.GetGCMemoryInfo().TotalAvailableMemoryBytes, _processMemoryCeilingBytes);
+            GC.GetGCMemoryInfo().TotalAvailableMemoryBytes, _processMemoryCeilingBytes, settings.RequiredHeadroomBytes);
         _verifiedRecords = result.VerifiedRecords;
         _verificationPasses++;
         _fullValueDigest = result.Digest;

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Fixtures/ScaledStorage/ScaledRawStorageIdentityReader.cs

@@ -41,10 +41,10 @@ internal static class ScaledRawStoragePreparationGuard
 {
     private const string DeadlineMessage = "The scaled fixture preparation deadline expired.";
 
-    internal static void Check(long deadlineStart, CancellationToken token)
+    internal static void Check(long deadlineStart, CancellationToken token, TimeSpan preparationTimeout)
     {
         token.ThrowIfCancellationRequested();
-        if (Stopwatch.GetElapsedTime(deadlineStart) >= ScaledRawStorageFixture.PreparationLimit)
+        if (Stopwatch.GetElapsedTime(deadlineStart) >= preparationTimeout)
         {
             throw new TimeoutException(DeadlineMessage);
         }
@@ -57,14 +57,14 @@ internal static class ScaledRawStorageSeedRunner
 
     internal static long Run(ScaledRawStorageCorpus corpus, ScaledRawStorageZoneTreeEngine engine,
         byte[] scratch, int recordCount, long deadlineStart, ref long attempts,
-        ref long successfulWrites, CancellationToken token)
+        ref long successfulWrites, CancellationToken token, TimeSpan preparationTimeout)
     {
         var started = Stopwatch.GetTimestamp();
         for (var index = 0; index < recordCount; index++)
         {
             if (index % CancellationCheckStride == 0)
             {
-                ScaledRawStoragePreparationGuard.Check(deadlineStart, token);
+                ScaledRawStoragePreparationGuard.Check(deadlineStart, token, preparationTimeout);
             }
 
             corpus.WriteValue(index, scratch);
@@ -73,7 +73,7 @@ internal static long Run(ScaledRawStorageCorpus corpus, ScaledRawStorageZoneTree
             successfulWrites++;
         }
 
-        ScaledRawStoragePreparationGuard.Check(deadlineStart, token);
+        ScaledRawStoragePreparationGuard.Check(deadlineStart, token, preparationTimeout);
         return Stopwatch.GetTimestamp() - started;
     }
 }

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Fixtures/ScaledStorage/ScaledRawStorageMemoryGuard.cs

@@ -2,19 +2,17 @@ namespace KeyLoad.BenchmarkScenarios.Features.BenchmarkComparisons;
 
 internal static class ScaledRawStorageMemoryGuard
 {
-    internal const long MaximumProcessBytes = 12L * 1024 * 1024 * 1024;
-    internal const long RequiredHeadroomBytes = 2L * 1024 * 1024 * 1024;
     private const string MemoryMessage = "Observed process memory exceeded the frozen ceiling or headroom.";
     private const string UnavailablePeakMessage = "The process did not provide a positive lifetime peak memory observation.";
 
-    internal static void ValidateObserved(long peak, long available, long ceiling)
+    internal static void ValidateObserved(long peak, long available, long ceiling, long requiredHeadroomBytes)
     {
         if (peak <= 0)
         {
             throw new InvalidDataException(UnavailablePeakMessage);
         }
 
-        if (peak > ceiling || checked(peak + RequiredHeadroomBytes) > available)
+        if (peak > ceiling || checked(peak + requiredHeadroomBytes) > available)
         {
             throw new InvalidOperationException(MemoryMessage);
         }

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Fixtures/ScaledStorage/ScaledRawStorageSettings.cs

@@ -6,7 +6,6 @@ internal static class ScaledRawStorageSettings
     private const int OneMillion = 1_000_000;
     private const int SmallPayloadBytes = 32;
     private const int LargePayloadBytes = 1024;
-    private const long FourteenGiB = 15_032_385_536L;
     private const int KeyBytes = 16;
     private const int ReservedMissKeyCount = 1;
     private const int OrderBytes = sizeof(int);
@@ -28,36 +27,36 @@ internal static void ValidateInput(int recordCount, int payloadBytes)
         }
     }
 
-    internal static long ValidateFixtureCapacity(int recordCount, int payloadBytes)
+    internal static long ValidateFixtureCapacity(int recordCount, int payloadBytes, ScaledStorageExecutionOptions settings)
     {
         ValidateInput(recordCount, payloadBytes);
         using var process = System.Diagnostics.Process.GetCurrentProcess();
         var projectedCeiling = checked(ScaledRawStorageProcessMemory.ReadPeakBytes(process)
-            + CapacityBound(recordCount, payloadBytes));
+            + CapacityBound(recordCount, payloadBytes, settings.RequiredHeadroomBytes));
         var available = GC.GetGCMemoryInfo().TotalAvailableMemoryBytes;
         var qualificationCount = recordCount is HundredThousand or OneMillion;
-        if (qualificationCount && available < FourteenGiB)
+        if (qualificationCount && available < settings.MinimumQualificationCapacityBytes)
         {
             throw new InvalidOperationException(InsufficientMemoryMessage);
         }
 
-        var ceiling = qualificationCount ? ScaledRawStorageMemoryGuard.MaximumProcessBytes : projectedCeiling;
-        if (projectedCeiling > ScaledRawStorageMemoryGuard.MaximumProcessBytes || ceiling > available)
+        var ceiling = qualificationCount ? settings.MaximumProcessBytes : projectedCeiling;
+        if (projectedCeiling > settings.MaximumProcessBytes || ceiling > available)
         {
             throw new InvalidOperationException(InsufficientMemoryMessage);
         }
 
         return ceiling;
     }
 
-    internal static long CapacityBound(int recordCount, int payloadBytes)
+    internal static long CapacityBound(int recordCount, int payloadBytes, long requiredHeadroomBytes)
     {
         var keysAndOrder = checked(((long)recordCount + ReservedMissKeyCount) * KeyBytes
             + ((long)recordCount * OrderBytes));
         var values = checked((long)recordCount * payloadBytes);
         var scratch = checked((long)payloadBytes * ScratchCopies);
         return checked(keysAndOrder + values + scratch
-            + ScaledRawStorageMemoryGuard.RequiredHeadroomBytes);
+            + requiredHeadroomBytes);
     }
 
 }

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Fixtures/ScaledStorage/ScaledRawStorageVerification.cs

@@ -13,14 +13,14 @@ internal static class ScaledRawStorageVerification
 
     internal static ScaledRawStorageVerificationResult Run(ScaledRawStorageCorpus corpus,
         ScaledRawStorageZoneTreeEngine engine, byte[] expectedScratch, int recordCount, ref long readCalls,
-        long deadlineStart, bool enforceBudget, CancellationToken token)
+        long deadlineStart, bool enforceBudget, CancellationToken token, TimeSpan preparationTimeout)
     {
         var started = Stopwatch.GetTimestamp();
         using var digest = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
         var verified = 0L;
         for (var index = 0; index < recordCount; index++)
         {
-            CheckBoundary(index, deadlineStart, enforceBudget, token);
+            CheckBoundary(index, deadlineStart, enforceBudget, token, preparationTimeout);
             readCalls++;
             if (!engine.TryRead(index, out var actual))
             {
@@ -37,43 +37,43 @@ internal static ScaledRawStorageVerificationResult Run(ScaledRawStorageCorpus co
             verified++;
         }
 
-        CheckBoundary(recordCount, deadlineStart, enforceBudget, token);
+        CheckBoundary(recordCount, deadlineStart, enforceBudget, token, preparationTimeout);
         readCalls++;
         if (engine.TryRead(recordCount, out _))
         {
             throw new InvalidOperationException(PresentMessage);
         }
 
-        CheckCompletion(deadlineStart, enforceBudget, token);
+        CheckCompletion(deadlineStart, enforceBudget, token, preparationTimeout);
         return new ScaledRawStorageVerificationResult(
             verified,
             Convert.ToHexStringLower(digest.GetHashAndReset()),
             Stopwatch.GetTimestamp() - started);
     }
 
-    private static void CheckBoundary(int operation, long deadlineStart, bool enforceBudget, CancellationToken token)
+    private static void CheckBoundary(int operation, long deadlineStart, bool enforceBudget, CancellationToken token, TimeSpan preparationTimeout)
     {
         if (!enforceBudget || operation % CancellationCheckStride != 0)
         {
             return;
         }
 
         token.ThrowIfCancellationRequested();
-        if (Stopwatch.GetElapsedTime(deadlineStart) >= ScaledRawStorageFixture.PreparationLimit)
+        if (Stopwatch.GetElapsedTime(deadlineStart) >= preparationTimeout)
         {
             throw new TimeoutException(DeadlineMessage);
         }
     }
 
-    private static void CheckCompletion(long deadlineStart, bool enforceBudget, CancellationToken token)
+    private static void CheckCompletion(long deadlineStart, bool enforceBudget, CancellationToken token, TimeSpan preparationTimeout)
     {
         if (!enforceBudget)
         {
             return;
         }
 
         token.ThrowIfCancellationRequested();
-        if (Stopwatch.GetElapsedTime(deadlineStart) >= ScaledRawStorageFixture.PreparationLimit)
+        if (Stopwatch.GetElapsedTime(deadlineStart) >= preparationTimeout)
         {
             throw new TimeoutException(DeadlineMessage);
         }