[Perf, Stress] Refactor options (Azure#17006)

Author: mikeharder

common/Perf/Azure.Test.Perf/PerfProgram.cs

@@ -109,8 +109,7 @@ private static async Task Run(Type testType, PerfOptions options)
 
                         if (options.Warmup > 0)
                         {
-                            await RunTestsAsync(tests, options.Sync, options.Parallel, options.Rate, options.Warmup, options.StatusInterval,
-                                "Warmup");
+                            await RunTestsAsync(tests, options, "Warmup", warmup: true);
                         }
 
                         for (var i = 0; i < options.Iterations; i++)
@@ -120,8 +119,7 @@ await RunTestsAsync(tests, options.Sync, options.Parallel, options.Rate, options
                             {
                                 title += " " + (i + 1);
                             }
-                            await RunTestsAsync(tests, options.Sync, options.Parallel, options.Rate, options.Duration, options.StatusInterval,
-                                title, options.JobStatistics, options.Latency);
+                            await RunTestsAsync(tests, options, title);
                         }
                     }
                     finally
@@ -162,24 +160,29 @@ await RunTestsAsync(tests, options.Sync, options.Parallel, options.Rate, options
             }
         }
 
-        private static async Task RunTestsAsync(IPerfTest[] tests, bool sync, int parallel, int? rate,
-            int durationSeconds, int statusIntervalSeconds, string title, bool jobStatistics = false, bool latency = false)
+        private static async Task RunTestsAsync(IPerfTest[] tests, PerfOptions options, string title, bool warmup = false)
         {
-            _completedOperations = new int[parallel];
-            _lastCompletionTimes = new TimeSpan[parallel];
+            var durationSeconds = warmup ? options.Warmup : options.Duration;
+
+            // Always disable jobStatistics and latency during warmup
+            var jobStatistics = warmup ? false : options.JobStatistics;
+            var latency = warmup ? false : options.Latency;
+
+            _completedOperations = new int[options.Parallel];
+            _lastCompletionTimes = new TimeSpan[options.Parallel];
 
             if (latency)
             {
-                _latencies = new List<TimeSpan>[parallel];
-                for (var i = 0; i < parallel; i++)
+                _latencies = new List<TimeSpan>[options.Parallel];
+                for (var i = 0; i < options.Parallel; i++)
                 {
                     _latencies[i] = new List<TimeSpan>();
                 }
 
-                if (rate.HasValue)
+                if (options.Rate.HasValue)
                 {
-                    _correctedLatencies = new List<TimeSpan>[parallel];
-                    for (var i = 0; i < parallel; i++)
+                    _correctedLatencies = new List<TimeSpan>[options.Parallel];
+                    for (var i = 0; i < options.Parallel; i++)
                     {
                         _correctedLatencies[i] = new List<TimeSpan>();
                     }
@@ -205,35 +208,35 @@ private static async Task RunTestsAsync(IPerfTest[] tests, bool sync, int parall
                 },
                 newLine: true,
                 progressStatusCts.Token,
-                statusIntervalSeconds
+                options.StatusInterval
                 );
 
             Thread pendingOperationsThread = null;
-            if (rate.HasValue)
+            if (options.Rate.HasValue)
             {
                 _pendingOperations = Channel.CreateUnbounded<ValueTuple<TimeSpan, Stopwatch>>();
-                pendingOperationsThread = WritePendingOperations(rate.Value, cancellationToken);
+                pendingOperationsThread = WritePendingOperations(options.Rate.Value, cancellationToken);
             }
 
-            if (sync)
+            if (options.Sync)
             {
-                var threads = new Thread[parallel];
+                var threads = new Thread[options.Parallel];
 
-                for (var i = 0; i < parallel; i++)
+                for (var i = 0; i < options.Parallel; i++)
                 {
                     var j = i;
                     threads[i] = new Thread(() => RunLoop(tests[j], j, latency, cancellationToken));
                     threads[i].Start();
                 }
-                for (var i = 0; i < parallel; i++)
+                for (var i = 0; i < options.Parallel; i++)
                 {
                     threads[i].Join();
                 }
             }
             else
             {
-                var tasks = new Task[parallel];
-                for (var i = 0; i < parallel; i++)
+                var tasks = new Task[options.Parallel];
+                for (var i = 0; i < options.Parallel; i++)
                 {
                     var j = i;
                     // Call Task.Run() instead of directly calling RunLoopAsync(), to ensure the requested

common/Stress/Azure.Test.Stress/StressProgram.cs

@@ -68,7 +68,7 @@ private static async Task Run(Type testType, StressOptions options)
                     setupStatusCts.Cancel();
                     setupStatusThread.Join();
 
-                    await RunTestAsync(test, options.Duration, options.StatusInterval, metrics);
+                    await RunTestAsync(test, options, metrics);
                 }
                 finally
                 {
@@ -184,9 +184,9 @@ private static void WriteEvents(StressMetrics metrics, string header, StressOpti
             }
         }
 
-        private static async Task RunTestAsync(IStressTest test, int durationSeconds, int statusIntervalSeconds, StressMetrics metrics)
+        private static async Task RunTestAsync(IStressTest test, StressOptions options, StressMetrics metrics)
         {
-            var duration = TimeSpan.FromSeconds(durationSeconds);
+            var duration = TimeSpan.FromSeconds(options.Duration);
             using var testCts = new CancellationTokenSource(duration);
             var cancellationToken = testCts.Token;
 
@@ -198,7 +198,7 @@ private static async Task RunTestAsync(IStressTest test, int durationSeconds, in
                 () => metrics.ToString(),
                 newLine: true,
                 progressStatusCts.Token,
-                statusIntervalSeconds);
+                options.StatusInterval);
 
             try
             {