Added ability to set target CPU percentage for CPU stress tests and improved UI feedback during slow request simulations.

Author: rhamlett_microsoft

src/PerfProblemSimulator/Controllers/CpuController.cs

@@ -103,21 +103,24 @@ public async Task<IActionResult> TriggerHighCpu(
     {
         // Use defaults if no request body provided
         var durationSeconds = request?.DurationSeconds ?? 30;
+        var targetPercentage = request?.TargetPercentage ?? 100;
 
         // Log the incoming request (FR-010: Request logging)
         _logger.LogInformation(
-            "Received CPU stress request: DurationSeconds={Duration}, ClientIP={ClientIP}",
+            "Received CPU stress request: DurationSeconds={Duration}, Percentage={Percentage}, ClientIP={ClientIP}",
             durationSeconds,
+            targetPercentage,
             HttpContext.Connection.RemoteIpAddress);
 
         try
         {
-            var result = await _cpuStressService.TriggerCpuStressAsync(durationSeconds, cancellationToken);
+            var result = await _cpuStressService.TriggerCpuStressAsync(durationSeconds, cancellationToken, targetPercentage);
 
             _logger.LogInformation(
-                "Started CPU stress simulation {SimulationId} for {Duration}s",
+                "Started CPU stress simulation {SimulationId} for {Duration}s @ {Percentage}%",
                 result.SimulationId,
-                result.ActualParameters?["DurationSeconds"]);
+                result.ActualParameters?["DurationSeconds"],
+                result.ActualParameters?["TargetPercentage"]);
 
             return Ok(result);
         }

src/PerfProblemSimulator/Models/CpuStressRequest.cs

@@ -35,4 +35,16 @@ public class CpuStressRequest
     /// </remarks>
     [Range(1, int.MaxValue, ErrorMessage = "Duration must be at least 1 second")]
     public int DurationSeconds { get; set; } = 30;
+
+    /// <summary>
+    /// The target CPU usage percentage (1-100).
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Default: 100%. Lower values use a duty cycle (work/sleep) to simulate
+    /// partial CPU load.
+    /// </para>
+    /// </remarks>
+    [Range(1, 100, ErrorMessage = "Target percentage must be between 1 and 100")]
+    public int TargetPercentage { get; set; } = 100;
 }

src/PerfProblemSimulator/Services/CpuStressService.cs

@@ -84,7 +84,7 @@ public CpuStressService(
     }
 
     /// <inheritdoc />
-    public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, CancellationToken cancellationToken)
+    public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, CancellationToken cancellationToken, int targetPercentage = 100)
     {
         // ==========================================================================
         // STEP 1: Validate the duration (no upper limits - app is meant to break)
@@ -93,6 +93,8 @@ public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, Cancell
             ? DefaultDurationSeconds
             : durationSeconds;
 
+        var actualPercentage = Math.Clamp(targetPercentage, 1, 100);
+
         var simulationId = Guid.NewGuid();
         var startedAt = DateTimeOffset.UtcNow;
         var estimatedEndAt = startedAt.AddSeconds(actualDuration);
@@ -108,16 +110,18 @@ public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, Cancell
         var parameters = new Dictionary<string, object>
         {
             ["DurationSeconds"] = actualDuration,
-            ["ProcessorCount"] = processorCount
+            ["ProcessorCount"] = processorCount,
+            ["TargetPercentage"] = actualPercentage
         };
 
         // Register this simulation with the tracker
         _simulationTracker.RegisterSimulation(simulationId, SimulationType.Cpu, parameters, cts);
 
         _logger.LogInformation(
-            "Starting CPU stress simulation {SimulationId}: {Duration}s across {ProcessorCount} cores",
+            "Starting CPU stress simulation {SimulationId}: {Duration}s @ {Percentage}% across {ProcessorCount} cores",
             simulationId,
             actualDuration,
+            actualPercentage,
             processorCount);
 
         // ==========================================================================
@@ -128,7 +132,7 @@ public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, Cancell
         // This is important because the caller (HTTP request) shouldn't be blocked
         // waiting for the entire duration.
 
-        _ = Task.Run(() => ExecuteCpuStress(simulationId, actualDuration, cts.Token), cts.Token);
+        _ = Task.Run(() => ExecuteCpuStress(simulationId, actualDuration, actualPercentage, cts.Token), cts.Token);
 
         // ==========================================================================
         // STEP 4: Return the result immediately
@@ -141,7 +145,7 @@ public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, Cancell
             SimulationId = simulationId,
             Type = SimulationType.Cpu,
             Status = "Started",
-            Message = $"CPU stress started on {processorCount} cores for {actualDuration} seconds. " +
+            Message = $"CPU stress started on {processorCount} cores for {actualDuration} seconds at {actualPercentage}%. " +
                       "Observe CPU metrics in Task Manager, dotnet-counters, or Application Insights. " +
                       "High CPU like this is typically caused by spin loops, inefficient algorithms, or infinite loops.",
             ActualParameters = parameters,
@@ -160,9 +164,9 @@ public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, Cancell
     /// <strong>⚠️ THIS IS AN ANTI-PATTERN - FOR EDUCATIONAL PURPOSES ONLY ⚠️</strong>
     /// </para>
     /// <para>
-    /// This method uses dedicated threads with spin loops to consume all available CPU cores.
-    /// Each thread runs a tight <c>while</c> loop that does nothing but check the time 
-    /// and cancellation token.
+    /// This method uses dedicated threads with spin loops to consume available CPU.
+    /// If targetPercentage is 100, it runs a tight loop.
+    /// If targetPercentage is less than 100, it uses a duty cycle (work/sleep) to simulate load.
     /// </para>
     /// <para>
     /// <strong>Why Dedicated Threads Instead of Parallel.For?</strong>
@@ -171,7 +175,7 @@ public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, Cancell
     /// thread pool remains available for the dashboard and metrics collection.
     /// </para>
     /// </remarks>
-    private void ExecuteCpuStress(Guid simulationId, int durationSeconds, CancellationToken cancellationToken)
+    private void ExecuteCpuStress(Guid simulationId, int durationSeconds, int targetPercentage, CancellationToken cancellationToken)
     {
         try
         {
@@ -182,27 +186,49 @@ private void ExecuteCpuStress(Guid simulationId, int durationSeconds, Cancellati
             // ==========================================================================
             // THE ANTI-PATTERN: Dedicated thread spin loops
             // ==========================================================================
-            // This code intentionally:
-            // 1. Creates one dedicated thread per CPU core
-            // 2. Each thread runs a tight while loop (spin loop)
-            // 3. The while loop continuously checks the time and does NOTHING useful
-            //
-            // We use dedicated threads instead of Parallel.For to avoid starving the
-            // thread pool, which would freeze the dashboard and SignalR.
-
+            // This code intentionally creates one dedicated thread per CPU core.
+            
             var threads = new Thread[processorCount];
 
             for (int i = 0; i < processorCount; i++)
             {
                 var threadIndex = i;
                 threads[i] = new Thread(() =>
                 {
-                    // This spin loop is the source of high CPU usage
-                    // It does nothing but burn CPU cycles checking conditions
-                    while (Stopwatch.GetTimestamp() < endTime && !cancellationToken.IsCancellationRequested)
+                    if (targetPercentage >= 99)
                     {
-                        // Intentionally empty - this is a spin loop
-                        // Every CPU cycle spent here is a wasted cycle
+                        // 100% Load: Tight spin loop (simplest, most effective for maxing out core)
+                        while (Stopwatch.GetTimestamp() < endTime && !cancellationToken.IsCancellationRequested)
+                        {
+                            // Intentionally empty - this is a spin loop
+                        }
+                    }
+                    else
+                    {
+                        // Partial Load: Duty Cycle
+                        // Work for X ms, Sleep for Y ms
+                        // Using a small window (e.g., 50ms) keeps usage relatively smooth
+                        const int windowMs = 50;
+                        int workMs = (windowMs * targetPercentage) / 100;
+                        int sleepMs = windowMs - workMs;
+
+                        while (Stopwatch.GetTimestamp() < endTime && !cancellationToken.IsCancellationRequested)
+                        {
+                            var cycleStart = Stopwatch.GetTimestamp();
+                            var workTicks = (workMs * Stopwatch.Frequency) / 1000;
+                            
+                            // Spin for work portion
+                            while (Stopwatch.GetTimestamp() - cycleStart < workTicks)
+                            {
+                                // Spin
+                            }
+
+                            // Sleep for remainder of window
+                            if (sleepMs > 0)
+                            {
+                                Thread.Sleep(sleepMs);
+                            }
+                        }
                     }
                 })
                 {

src/PerfProblemSimulator/Services/ICpuStressService.cs

@@ -26,6 +26,9 @@ public interface ICpuStressService
     /// <param name="cancellationToken">
     /// Token to request early cancellation of the stress operation.
     /// </param>
+    /// <param name="targetPercentage">
+    /// Target CPU usage percentage (1-100). Default is 100.
+    /// </param>
     /// <returns>
     /// A result containing the simulation ID, actual parameters used, and timing information.
     /// </returns>
@@ -43,5 +46,5 @@ public interface ICpuStressService
     /// </list>
     /// </para>
     /// </remarks>
-    Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, CancellationToken cancellationToken);
+    Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, CancellationToken cancellationToken, int targetPercentage = 100);
 }

src/PerfProblemSimulator/wwwroot/index.html

@@ -44,6 +44,9 @@ <h3>🔥 CPU Stress</h3>
                     <label>Duration (s):
                         <input type="number" id="cpuDuration" value="10" min="1" title="Duration in seconds (minimum 1 second)">
                     </label>
+                    <label>Target CPU (%):
+                        <input type="number" id="cpuTarget" value="100" min="1" max="100" title="Target CPU load percentage (1-100)">
+                    </label>
                 </div>
                 <button class="btn btn-danger" id="btnTriggerCpu">🔥 Trigger High CPU</button>
             </div>

src/PerfProblemSimulator/wwwroot/js/dashboard.js

@@ -761,18 +761,22 @@ function stopClientProbe() {
 
 async function triggerCpuStress() {
     const duration = parseInt(document.getElementById('cpuDuration').value) || 10;
+    const target = parseInt(document.getElementById('cpuTarget').value) || 100;
 
     try {
-        logEvent('info', `Triggering CPU stress for ${duration} seconds...`);
+        logEvent('info', `Triggering CPU stress for ${duration} seconds @ ${target}%...`);
         const response = await fetch(`${CONFIG.apiBaseUrl}/cpu/trigger-high-cpu`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ durationSeconds: duration })
+            body: JSON.stringify({ 
+                durationSeconds: duration,
+                targetPercentage: target
+            })
         });
 
         if (response.ok) {
             const result = await response.json();
-            addActiveSimulation(result.simulationId, 'cpu', 'CPU Stress');
+            addActiveSimulation(result.simulationId, 'cpu', `CPU Stress (${target}%)`);
             logEvent('success', `CPU stress started: ${result.simulationId}`);
         } else {
             const error = await response.json();