Increase testing aggresiveness.

Author: rhamlett_microsoft

src/PerfProblemSimulator/Controllers/LoadTestController.cs

@@ -137,7 +137,7 @@ public LoadTestController(
      * 3. Allows structured parameters in request body
      * 
      * ALTERNATIVE: GET with query parameters
-     * GET /api/loadtest?workIterations=1000&bufferSizeKb=5
+     * GET /api/loadtest?workIterations=1000&bufferSizeKb=100
      * Simpler but less flexible for complex parameters.
      * 
      * URL PATTERN:
@@ -150,8 +150,9 @@ public LoadTestController(
     /// </summary>
     /// <param name="workIterations">Number of SHA256 hash iterations (default: 1000).</param>
     /// <param name="bufferSizeKb">Memory buffer size in KB (default: 100).</param>
-    /// <param name="softLimit">Concurrent request soft limit (default: 10).</param>
-    /// <param name="degradationFactor">Delay ms per request over limit (default: 50).</param>
+    /// <param name="baselineDelayMs">Minimum blocking delay in ms (default: 500).</param>
+    /// <param name="softLimit">Concurrent request soft limit (default: 5).</param>
+    /// <param name="degradationFactor">Delay ms per request over limit (default: 200).</param>
     /// <param name="cancellationToken">Cancellation token from the HTTP request pipeline.</param>
     /// <returns>Load test result with timing and diagnostic information.</returns>
     /// <remarks>
@@ -160,12 +161,13 @@ public LoadTestController(
     /// </para>
     /// <para>
     /// 1. Start a timer (Stopwatch)
-    /// 2. Check current concurrent request count
-    /// 3. If over soft limit, calculate and apply degradation delay
-    /// 4. Perform lightweight CPU work (hash iterations)
-    /// 5. Allocate small memory buffer (released when request ends)
-    /// 6. Periodically check if elapsed time > 120s; if so, 20% chance of exception
-    /// 7. Return response with timing details
+    /// 2. Apply baseline blocking delay (guarantees thread pool exhaustion)
+    /// 3. Check current concurrent request count
+    /// 4. If over soft limit, calculate and apply degradation delay
+    /// 5. Perform lightweight CPU work (hash iterations)
+    /// 6. Allocate memory buffer (released when request ends)
+    /// 7. Periodically check if elapsed time > 120s; if so, 20% chance of exception
+    /// 8. Return response with timing details
     /// </para>
     /// <para>
     /// <strong>PARAMETERS:</strong>
@@ -180,27 +182,32 @@ public LoadTestController(
     /// <description>Size of memory buffer to allocate in kilobytes. Released after request.</description>
     /// </item>
     /// <item>
-    /// <term>softLimit (default: 10)</term>
+    /// <term>baselineDelayMs (default: 500)</term>
+    /// <description>Minimum blocking delay applied to every request. Ensures thread pool exhaustion.</description>
+    /// </item>
+    /// <item>
+    /// <term>softLimit (default: 5)</term>
     /// <description>Concurrent request count before degradation delays begin.</description>
     /// </item>
     /// <item>
-    /// <term>degradationFactor (default: 50)</term>
+    /// <term>degradationFactor (default: 200)</term>
     /// <description>Milliseconds of delay added per concurrent request over the soft limit.</description>
     /// </item>
     /// </list>
     /// <para>
-    /// <strong>DEGRADATION FORMULA:</strong>
+    /// <strong>TOTAL DELAY FORMULA:</strong>
     /// <code>
-    /// additionalDelayMs = max(0, currentConcurrent - softLimit) * degradationFactor
+    /// totalDelay = baselineDelayMs + max(0, currentConcurrent - softLimit) * degradationFactor
     /// </code>
     /// </para>
     /// <para>
-    /// <strong>EXAMPLE SCENARIOS:</strong>
+    /// <strong>EXAMPLE SCENARIOS (with defaults baselineDelayMs=500, softLimit=5, factor=200):</strong>
     /// </para>
     /// <list type="bullet">
-    /// <item>10 concurrent requests, softLimit=50 → 0ms added delay</item>
-    /// <item>60 concurrent requests, softLimit=50, factor=5 → 50ms added delay</item>
-    /// <item>150 concurrent requests, softLimit=50, factor=5 → 500ms added delay</item>
+    /// <item>1 concurrent request → 500ms baseline only</item>
+    /// <item>10 concurrent requests → 500ms + (10-5)×200 = 1500ms total</item>
+    /// <item>20 concurrent requests → 500ms + (20-5)×200 = 3500ms total</item>
+    /// <item>50 concurrent requests → 500ms + (50-5)×200 = 9500ms total</item>
     /// </list>
     /// </remarks>
     /// <response code="200">Load test completed successfully with timing details.</response>
@@ -212,8 +219,9 @@ public LoadTestController(
     public async Task<IActionResult> ExecuteLoadTest(
         [FromQuery] int workIterations = 1000,
         [FromQuery] int bufferSizeKb = 100,
-        [FromQuery] int softLimit = 10,
-        [FromQuery] int degradationFactor = 50,
+        [FromQuery] int baselineDelayMs = 500,
+        [FromQuery] int softLimit = 5,
+        [FromQuery] int degradationFactor = 200,
         CancellationToken cancellationToken = default)
     {
         /*
@@ -225,8 +233,8 @@ public async Task<IActionResult> ExecuteLoadTest(
          * with Azure Load Testing, JMeter, and browser testing.
          * 
          * Examples:
-         * - GET/POST /api/loadtest (uses all defaults)
-         * - GET/POST /api/loadtest?softLimit=25&degradationFactor=10
+         * - GET/POST /api/loadtest (uses all defaults - maximum stress)
+         * - GET/POST /api/loadtest?baselineDelayMs=200&softLimit=20&degradationFactor=50
          * 
          * PORTING NOTES:
          * - Query parameters are universal across HTTP clients
@@ -239,6 +247,7 @@ public async Task<IActionResult> ExecuteLoadTest(
         {
             WorkIterations = workIterations,
             BufferSizeKb = bufferSizeKb,
+            BaselineDelayMs = baselineDelayMs,
             SoftLimit = softLimit,
             DegradationFactor = degradationFactor
         };
@@ -302,8 +311,9 @@ public async Task<IActionResult> ExecuteLoadTest(
     /// </summary>
     /// <param name="workIterations">Number of hash iterations (default: 1000).</param>
     /// <param name="bufferSizeKb">Memory buffer size in KB (default: 100).</param>
-    /// <param name="softLimit">Concurrent request soft limit (default: 10).</param>
-    /// <param name="degradationFactor">Delay ms per request over limit (default: 50).</param>
+    /// <param name="baselineDelayMs">Minimum blocking delay in ms (default: 500).</param>
+    /// <param name="softLimit">Concurrent request soft limit (default: 5).</param>
+    /// <param name="degradationFactor">Delay ms per request over limit (default: 200).</param>
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>Load test result with timing details.</returns>
     [HttpGet("probe")]
@@ -312,8 +322,9 @@ public async Task<IActionResult> ExecuteLoadTest(
     public async Task<IActionResult> ExecuteLoadTestProbe(
         [FromQuery] int workIterations = 1000,
         [FromQuery] int bufferSizeKb = 100,
-        [FromQuery] int softLimit = 10,
-        [FromQuery] int degradationFactor = 50,
+        [FromQuery] int baselineDelayMs = 500,
+        [FromQuery] int softLimit = 5,
+        [FromQuery] int degradationFactor = 200,
         CancellationToken cancellationToken = default)
     {
         /*
@@ -332,7 +343,7 @@ public async Task<IActionResult> ExecuteLoadTestProbe(
          */
 
         // Delegate to main endpoint - both now use query parameters
-        return await ExecuteLoadTest(workIterations, bufferSizeKb, softLimit, degradationFactor, cancellationToken);
+        return await ExecuteLoadTest(workIterations, bufferSizeKb, baselineDelayMs, softLimit, degradationFactor, cancellationToken);
     }
 
     /*

src/PerfProblemSimulator/Models/LoadTestRequest.cs

@@ -11,8 +11,9 @@
  * {
  *     "workIterations": 1000,
  *     "bufferSizeKb": 100,
- *     "softLimit": 10,
- *     "degradationFactor": 50
+ *     "baselineDelayMs": 500,
+ *     "softLimit": 5,
+ *     "degradationFactor": 200
  * }
  * 
  * OR with defaults (empty body or null):
@@ -56,19 +57,26 @@ namespace PerfProblemSimulator.Models;
 /// <term>softLimit</term>
 /// <description>
 /// Concurrent requests before degradation starts. Lower = earlier degradation.
-/// Tune based on expected normal load. 10 is aggressive for testing timeouts.
+/// Default of 5 ensures rapid escalation under load.
 /// </description>
 /// </item>
 /// <item>
 /// <term>degradationFactor</term>
 /// <description>
 /// Milliseconds of delay added per request OVER the soft limit.
-/// Higher = steeper degradation curve. 50ms is aggressive.
+/// Default of 200ms creates steep degradation curve.
 /// 
-/// Example: softLimit=10, degradationFactor=50
-/// - 20 concurrent: (20-10) * 50 = 500ms added delay
-/// - 50 concurrent: (50-10) * 50 = 2000ms added delay
-/// - 100 concurrent: (100-10) * 50 = 4500ms added delay
+/// Example: softLimit=5, degradationFactor=200
+/// - 10 concurrent: (10-5) * 200 = 1000ms added delay
+/// - 20 concurrent: (20-5) * 200 = 3000ms added delay
+/// - 50 concurrent: (50-5) * 200 = 9000ms added delay
+/// </description>
+/// </item>
+/// <item>
+/// <term>baselineDelayMs</term>
+/// <description>
+/// Minimum blocking delay for every request. Default 500ms ensures
+/// thread pool exhaustion under any significant load.
 /// </description>
 /// </item>
 /// </list>
@@ -134,7 +142,7 @@ public class LoadTestRequest
     /// </summary>
     /// <remarks>
     /// <para>
-    /// <strong>DEFAULT: 10</strong>
+    /// <strong>DEFAULT: 5</strong>
     /// </para>
     /// <para>
     /// When concurrent requests exceed this limit, additional delay is
@@ -154,14 +162,14 @@ public class LoadTestRequest
     /// </list>
     /// </para>
     /// </remarks>
-    public int SoftLimit { get; set; } = 10;
+    public int SoftLimit { get; set; } = 5;
 
     /// <summary>
     /// Milliseconds of delay added per concurrent request over the soft limit.
     /// </summary>
     /// <remarks>
     /// <para>
-    /// <strong>DEFAULT: 50 ms</strong>
+    /// <strong>DEFAULT: 200 ms</strong>
     /// </para>
     /// <para>
     /// <strong>DEGRADATION FORMULA:</strong>
@@ -170,25 +178,42 @@ public class LoadTestRequest
     /// </code>
     /// </para>
     /// <para>
-    /// <strong>EXAMPLES (softLimit=10, degradationFactor=50):</strong>
+    /// <strong>EXAMPLES (softLimit=5, degradationFactor=200):</strong>
     /// <list type="bullet">
-    /// <item>5 concurrent → 0ms added (below soft limit)</item>
-    /// <item>20 concurrent → 500ms added ((20-10) × 50)</item>
-    /// <item>50 concurrent → 2000ms added ((50-10) × 50)</item>
-    /// <item>100 concurrent → 4500ms added ((100-10) × 50)</item>
-    /// <item>200 concurrent → 9500ms added ((200-10) × 50)</item>
+    /// <item>5 concurrent → 0ms added (at soft limit)</item>
+    /// <item>10 concurrent → 1000ms added ((10-5) × 200)</item>
+    /// <item>20 concurrent → 3000ms added ((20-5) × 200)</item>
+    /// <item>50 concurrent → 9000ms added ((50-5) × 200)</item>
+    /// <item>100 concurrent → 19000ms added ((100-5) × 200)</item>
     /// </list>
     /// </para>
     /// <para>
     /// <strong>REACHING 230s TIMEOUT:</strong>
     /// To reach Azure's 230s timeout with these defaults:
-    /// (230000ms - 100ms base) / 50ms = 4598 requests over soft limit
-    /// So: 10 + 4598 = ~4608 concurrent requests
-    /// 
-    /// For lighter degradation, decrease degradationFactor:
-    /// - degradationFactor=25: ~9200 concurrent requests to timeout
-    /// - degradationFactor=10: ~23000 concurrent requests to timeout
+    /// (230000ms - 500ms baseline) / 200ms = ~1147 requests over soft limit
+    /// So: 5 + 1147 = ~1152 concurrent requests to timeout
+    /// </para>
+    /// </remarks>
+    public int DegradationFactor { get; set; } = 200;
+
+    /// <summary>
+    /// Minimum blocking delay applied to every request in milliseconds.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <strong>DEFAULT: 500 ms</strong>
+    /// </para>
+    /// <para>
+    /// This baseline delay is applied BEFORE the degradation calculation.
+    /// It ensures every request blocks a thread for at least this duration,
+    /// guaranteeing thread pool exhaustion under any significant load.
+    /// </para>
+    /// <para>
+    /// Combined with degradation factor, total delay is:
+    /// <code>
+    /// totalDelay = baselineDelayMs + max(0, concurrent - softLimit) * degradationFactor
+    /// </code>
     /// </para>
     /// </remarks>
-    public int DegradationFactor { get; set; } = 50;
+    public int BaselineDelayMs { get; set; } = 500;
 }

src/PerfProblemSimulator/Services/LoadTestService.cs

@@ -445,28 +445,50 @@ public async Task<LoadTestResult> ExecuteWorkAsync(LoadTestRequest request, Canc
         try
         {
             /*
-             * STEP 3: CALCULATE DEGRADATION DELAY
+             * STEP 3A: APPLY BASELINE BLOCKING DELAY
+             * =================================================================
+             * 
+             * Every request blocks for at least baselineDelayMs, regardless of
+             * concurrent request count. This GUARANTEES thread pool exhaustion
+             * under any significant load.
+             * 
+             * THREAD BLOCKING:
+             * We use Thread.Sleep to BLOCK threads. At 500ms baseline with 
+             * high request rate, threads will exhaust rapidly.
+             */
+            if (request.BaselineDelayMs > 0)
+            {
+                _logger.LogDebug("Applying baseline blocking delay: {Delay}ms", request.BaselineDelayMs);
+                Thread.Sleep(request.BaselineDelayMs);
+                degradationDelayApplied += request.BaselineDelayMs;
+                
+                // Check for timeout exception after baseline delay
+                CheckAndThrowTimeoutException(stopwatch);
+            }
+            
+            /*
+             * STEP 3B: CALCULATE DEGRADATION DELAY
              * =================================================================
              * 
              * FORMULA:
              *   overLimit = max(0, currentConcurrent - softLimit)
              *   delayMs = overLimit * degradationFactor
              * 
-             * EXAMPLES (with softLimit=50, degradationFactor=5):
-             *   - 30 concurrent → overLimit=0 → delay=0ms
-             *   - 50 concurrent → overLimit=0 → delay=0ms
-             *   - 60 concurrent → overLimit=10 → delay=50ms
-             *   - 100 concurrent → overLimit=50 → delay=250ms
-             *   - 200 concurrent → overLimit=150 → delay=750ms
+             * EXAMPLES (with softLimit=5, degradationFactor=200):
+             *   - 5 concurrent → overLimit=0 → delay=0ms
+             *   - 10 concurrent → overLimit=5 → delay=1000ms
+             *   - 20 concurrent → overLimit=15 → delay=3000ms
+             *   - 50 concurrent → overLimit=45 → delay=9000ms
+             *   - 100 concurrent → overLimit=95 → delay=19000ms
              * 
-             * This creates a LINEAR degradation curve above the soft limit.
+             * Combined with baseline 500ms, total delays become significant quickly.
              */
             var overLimit = Math.Max(0, currentConcurrent - request.SoftLimit);
             var totalDegradationDelayMs = overLimit * request.DegradationFactor;
 
             _logger.LogDebug(
-                "Load test: Concurrent={Concurrent}, OverLimit={OverLimit}, DegradationDelay={Delay}ms",
-                currentConcurrent, overLimit, totalDegradationDelayMs);
+                "Load test: Concurrent={Concurrent}, OverLimit={OverLimit}, BaselineDelay={Baseline}ms, DegradationDelay={Delay}ms",
+                currentConcurrent, overLimit, request.BaselineDelayMs, totalDegradationDelayMs);
 
             /*
              * STEP 4: APPLY DEGRADATION DELAY (with exception checks)