Checkpoint current Aspire options and SQL changes

Save all remaining current working-tree changes on main at the owner request. Parallel implementation remains in progress. This is an unqualified source checkpoint; required build, functional coverage and complete test gates remain open.

Author: KSemenenko

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Configuration/OpenLoopExecutionOptions.cs

@@ -1,5 +1,4 @@
 using KeyLoad;
-using Microsoft.Extensions.Options;
 
 namespace KeyLoad.Comparisons;
 
@@ -44,26 +43,3 @@ internal static OpenLoopExecutionPolicy Snapshot(OpenLoopExecutionOptions option
             options.ControlPollMilliseconds, options.SpinWindowMicroseconds);
     }
 }
-
-/// <summary>Rejects any options that differ from the qualified open-loop execution policy.</summary>
-public sealed class OpenLoopExecutionOptionsValidator : IValidateOptions<OpenLoopExecutionOptions>
-{
-    private const string ValidationFailureMessage = "Open-loop execution policy must match the qualified v1 cohort.";
-
-    /// <inheritdoc />
-    public ValidateOptionsResult Validate(string? name, OpenLoopExecutionOptions options)
-    {
-        ArgumentNullException.ThrowIfNull(options);
-        return IsExact(options) ? ValidateOptionsResult.Success
-            : ValidateOptionsResult.Fail(ValidationFailureMessage);
-    }
-
-    private static bool IsExact(OpenLoopExecutionOptions options)
-        => options.QueueCapacity == OpenLoopExecutionOptions.DefaultQueueCapacity
-            && options.ConcurrentSessions == OpenLoopExecutionOptions.DefaultConcurrentSessions
-            && options.MaximumNodes == OpenLoopExecutionOptions.DefaultMaximumNodes
-            && options.OperationDeadlineMilliseconds == OpenLoopExecutionOptions.DefaultOperationDeadlineMilliseconds
-            && options.DrainMilliseconds == OpenLoopExecutionOptions.DefaultDrainMilliseconds
-            && options.ControlPollMilliseconds == OpenLoopExecutionOptions.DefaultControlPollMilliseconds
-            && options.SpinWindowMicroseconds == OpenLoopExecutionOptions.DefaultSpinWindowMicroseconds;
-}

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Configuration/OpenLoopExecutionOptionsValidator.cs

@@ -0,0 +1,26 @@
+using Microsoft.Extensions.Options;
+
+namespace KeyLoad.Comparisons;
+
+/// <summary>Rejects any options that differ from the qualified open-loop execution policy.</summary>
+public sealed class OpenLoopExecutionOptionsValidator : IValidateOptions<OpenLoopExecutionOptions>
+{
+    private const string ValidationFailureMessage = "Open-loop execution policy must match the qualified v1 cohort.";
+
+    /// <inheritdoc />
+    public ValidateOptionsResult Validate(string? name, OpenLoopExecutionOptions options)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+        return IsExact(options) ? ValidateOptionsResult.Success
+            : ValidateOptionsResult.Fail(ValidationFailureMessage);
+    }
+
+    private static bool IsExact(OpenLoopExecutionOptions options)
+        => options.QueueCapacity == OpenLoopExecutionOptions.DefaultQueueCapacity
+            && options.ConcurrentSessions == OpenLoopExecutionOptions.DefaultConcurrentSessions
+            && options.MaximumNodes == OpenLoopExecutionOptions.DefaultMaximumNodes
+            && options.OperationDeadlineMilliseconds == OpenLoopExecutionOptions.DefaultOperationDeadlineMilliseconds
+            && options.DrainMilliseconds == OpenLoopExecutionOptions.DefaultDrainMilliseconds
+            && options.ControlPollMilliseconds == OpenLoopExecutionOptions.DefaultControlPollMilliseconds
+            && options.SpinWindowMicroseconds == OpenLoopExecutionOptions.DefaultSpinWindowMicroseconds;
+}

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Contracts/OpenLoopCancellationProofV1.cs

@@ -39,6 +39,20 @@ public sealed record OpenLoopNativeCompletionV1(string ProfileId, Scenario Scena
 /// <summary>Names and bounds the separate child-process cancellation proof artifacts.</summary>
 public static class OpenLoopCancellationProofContract
 {
+    /// <summary>Gets the fixed cancellation proof schema version.</summary>
+    public const int SchemaVersion = 1;
+    /// <summary>Gets the fixed pending proof path name beneath the owned output directory.</summary>
+    public const string PendingProofFileName = ".open-loop-cancellation-proof.v1.json.pending";
+    /// <summary>Gets the fixed marker field separator.</summary>
+    public const char MarkerFieldSeparator = '|';
+    /// <summary>Gets the exact request bytes.</summary>
+    public const int RequestBytes = 10;
+    /// <summary>Gets the bounded request read buffer size, including one excess byte.</summary>
+    public const int RequestReadBufferBytes = 11;
+    /// <summary>Gets the exact number of fields in the marker.</summary>
+    public const int CompletionMarkerFieldCount = 7;
+    /// <summary>Gets the largest ASCII code point admitted by the marker format.</summary>
+    public const int MaximumMarkerAsciiCodePoint = 0x7F;
     /// <summary>Gets the fixed request path name beneath the owned output directory.</summary>
     public const string RequestFileName = "open-loop-cancel.v1.request";
     /// <summary>Gets the fixed pending request path name beneath the owned output directory.</summary>
@@ -49,6 +63,8 @@ public static class OpenLoopCancellationProofContract
     public const string CompletionMarkerPrefix = "OpenLoopNativeCompletionV1";
     /// <summary>Gets the fixed request token bytes.</summary>
     public const string RequestText = "cancel-v1\n";
+    /// <summary>Gets the asynchronous JSON writer buffer size in bytes.</summary>
+    public const int JsonWriterBufferBytes = 8_192;
     /// <summary>Gets the maximum proof artifact size in bytes.</summary>
     public const int MaximumProofBytes = 4 * 1024 * 1024;
     /// <summary>Gets the maximum child marker length in ASCII bytes.</summary>

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Contracts/OpenLoopEvidenceContract.cs

@@ -0,0 +1,28 @@
+namespace KeyLoad.Comparisons;
+
+/// <summary>Owns immutable identities and bounds for the separate open-loop evidence format.</summary>
+internal static class OpenLoopEvidenceContract
+{
+    internal const int SchemaVersion = 1;
+    internal const int MaximumArtifactBytes = 4 * 1024 * 1024;
+    internal const int JsonWriterBufferBytes = 16_384;
+    internal const int Sha256HexCharacters = 64;
+    internal const int GitRevisionHexCharacters = 40;
+    internal const int MaximumWorkerTargetCharacters = 256;
+    internal const int MaximumProfileIdCharacters = 64;
+    internal const int MaximumWorkerSourceRevisionCharacters = 64;
+    internal const int MaximumRepositoryCharacters = 512;
+    internal const int MaximumRefCharacters = 512;
+    internal const int MaximumWorkflowCharacters = 256;
+    internal const int MaximumStorageDescriptionCharacters = 512;
+    internal const int MaximumRuntimeDescriptionCharacters = 256;
+    internal const int MaximumTargetFieldCharacters = 2_048;
+    internal const int MaximumTargetMetadataBytes = 8_192;
+    internal const int MaximumClusterObservations = 64;
+    internal const int MaximumObservationCharacters = 1_024;
+    internal const int MaximumObservationBytes = 8_192;
+
+    internal const string OpenLoopEvidenceFileName = "open-loop-evidence.v1.json";
+    internal const string PendingOpenLoopEvidenceFileName = ".open-loop-evidence.v1.json.pending";
+    internal const string ProgressMessageFormat = "open-loop {0} {1}/s: {2}/{3} succeeded";
+}

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Contracts/OpenLoopExecutionPolicy.cs

@@ -7,6 +7,10 @@ public sealed record OpenLoopExecutionPolicy(int QueueCapacity, int ConcurrentSe
     int OperationDeadlineMilliseconds, int DrainMilliseconds, int ControlPollMilliseconds,
     int SpinWindowMicroseconds)
 {
+    private const int MillisecondsPerSecond = 1_000;
+    private const int MicrosecondsPerSecond = 1_000_000;
+    private const int CeilingRoundingAdjustment = 1;
+
     /// <summary>Checks that evidence carries the single currently qualified v1 policy.</summary>
     /// <returns>Whether all seven values match the canonical options definition.</returns>
     internal bool IsQualifiedV1()
@@ -19,17 +23,17 @@ internal bool IsQualifiedV1()
             && SpinWindowMicroseconds == OpenLoopExecutionOptions.DefaultSpinWindowMicroseconds;
 
     internal long OperationDeadlineTicks
-        => ToStopwatchTicks(OperationDeadlineMilliseconds, 1_000);
+        => ToStopwatchTicks(OperationDeadlineMilliseconds, MillisecondsPerSecond);
 
     internal long DrainTicks
-        => ToStopwatchTicks(DrainMilliseconds, 1_000);
+        => ToStopwatchTicks(DrainMilliseconds, MillisecondsPerSecond);
 
     internal long SpinWindowTicks
-        => ToStopwatchTicks(SpinWindowMicroseconds, 1_000_000);
+        => ToStopwatchTicks(SpinWindowMicroseconds, MicrosecondsPerSecond);
 
     private static long ToStopwatchTicks(int amount, int unitsPerSecond)
     {
         var numerator = checked((long)amount * Stopwatch.Frequency);
-        return checked((numerator + unitsPerSecond - 1) / unitsPerSecond);
+        return checked((numerator + unitsPerSecond - CeilingRoundingAdjustment) / unitsPerSecond);
     }
 }

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Diagnostics/OpenLoopFailureMessages.cs

@@ -0,0 +1,7 @@
+namespace KeyLoad.Comparisons;
+
+internal static class OpenLoopFailureMessages
+{
+    internal const string CellOutsideFrozenProfile = "The open-loop cell is outside its frozen profile.";
+    internal const string CancellationProofCellUnsupported = "The cancellation proof cell is unsupported.";
+}

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Diagnostics/ScaledCorpusReadbackFailureCodes.cs

@@ -0,0 +1,9 @@
+namespace KeyLoad.Comparisons;
+
+internal static class ScaledCorpusReadbackFailureCodes
+{
+    internal const string Operation = "ScaledCorpusReadback";
+    internal const string ExtraRecord = "ScaledCorpusReadbackExtraRecord";
+    internal const string CursorDidNotAdvance = "ScaledCorpusReadbackCursorDidNotAdvance";
+    internal const string CountMismatch = "ScaledCorpusReadbackCountMismatch";
+}

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Execution/ComparisonSessionCleanup.cs

@@ -7,6 +7,7 @@ namespace KeyLoad.Comparisons;
 internal static class ComparisonSessionCleanup
 {
     internal const string Failure = "ComparisonSessionCleanupFailed";
+    private const int MinimumTimeoutSeconds = 1;
 
     internal static async Task<bool> CloseAsync(IEnumerable<IComparisonSession> sessions, int timeoutSeconds)
     {
@@ -19,7 +20,7 @@ internal static Task<ComparisonSessionCloseResult> CloseAndJoinAsync(
         IEnumerable<IComparisonSession> sessions, int timeoutSeconds)
     {
         ArgumentNullException.ThrowIfNull(sessions);
-        ArgumentOutOfRangeException.ThrowIfLessThan(timeoutSeconds, 1);
+        ArgumentOutOfRangeException.ThrowIfLessThan(timeoutSeconds, MinimumTimeoutSeconds);
         return CloseAndJoinAsync(sessions, TimeSpan.FromSeconds(timeoutSeconds));
     }
 

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Execution/OpenLoopCancellationProofRunner.cs

@@ -99,7 +99,7 @@ private static void ValidateArguments(ScaledComparisonProfile profile, int rate,
             || !OpenLoopRateContract.AcceptedRates.Contains(rate) || target.Profile.Name != OpenLoopProtocolIdentities.KeyLoadTarget
             || !target.Supports(Scenario.PointRead))
         {
-            throw new ArgumentOutOfRangeException(nameof(worker), "The cancellation proof cell is unsupported.");
+            throw new ArgumentOutOfRangeException(nameof(worker), OpenLoopFailureMessages.CancellationProofCellUnsupported);
         }
     }
 
@@ -136,7 +136,7 @@ private static async Task<OpenLoopWatcherSettlement> StopAndJoinWatcherAsync(
 
     private static OpenLoopCancellationProofV1 CreateProof(OpenLoopComparisonReport report,
         OpenLoopProgressV1 milestone, OpenLoopHealthyReadResult health)
-        => new(1, report.Worker!, report.ProfileId, report.OfferedRatePerSecond, report.Scenario,
+        => new(OpenLoopCancellationProofContract.SchemaVersion, report.Worker!, report.ProfileId, report.OfferedRatePerSecond, report.Scenario,
             report.DatasetRecords, report.DatasetSha256, milestone, report.Accounting, report.ExecutionPolicy,
             report.CallerCancelled,
             true, true, report.SessionsClosed, true, health.Revision, health.JsonSha256, health.SessionClosed);

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/Execution/OpenLoopCancellationRequestWatcher.cs

@@ -4,8 +4,6 @@ namespace KeyLoad.Comparisons;
 
 internal static class OpenLoopCancellationRequestWatcher
 {
-    private const int RequestBytes = 10;
-    private const int ReadLimit = 11;
 
     internal static void ValidateFresh(string output)
     {
@@ -71,13 +69,13 @@ private static void ValidateRequestAttributes(string path, FileAttributes attrib
     private static async Task ValidateRequestAsync(string path, CancellationToken cancellationToken)
     {
         var info = new FileInfo(path);
-        if (info.Length != RequestBytes)
+        if (info.Length != OpenLoopCancellationProofContract.RequestBytes)
         {
             throw new ComparisonFailureException(OpenLoopFailureCodes.OpenLoopCancellationControlInvalid);
         }
-        var bytes = new byte[ReadLimit];
+        var bytes = new byte[OpenLoopCancellationProofContract.RequestReadBufferBytes];
         await using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read,
-            ReadLimit, FileOptions.Asynchronous | FileOptions.SequentialScan);
+            OpenLoopCancellationProofContract.RequestReadBufferBytes, FileOptions.Asynchronous | FileOptions.SequentialScan);
         var read = 0;
         while (read < bytes.Length)
         {
@@ -86,7 +84,7 @@ private static async Task ValidateRequestAsync(string path, CancellationToken ca
             read += count;
         }
         var expected = Encoding.UTF8.GetBytes(OpenLoopCancellationProofContract.RequestText);
-        if (read != RequestBytes || !bytes.AsSpan(0, RequestBytes).SequenceEqual(expected))
+        if (read != OpenLoopCancellationProofContract.RequestBytes || !bytes.AsSpan(0, OpenLoopCancellationProofContract.RequestBytes).SequenceEqual(expected))
         {
             throw new ComparisonFailureException(OpenLoopFailureCodes.OpenLoopCancellationControlInvalid);
         }