Perf Tests: Fix test time with max steps performed.

src/tests/perf_tests/ANGLEPerfTest.cpp

@@ -40,7 +40,6 @@ constexpr size_t kInitialTraceEventBufferSize = 50000;
 constexpr double kMilliSecondsPerSecond       = 1e3;
 constexpr double kMicroSecondsPerSecond       = 1e6;
 constexpr double kNanoSecondsPerSecond        = 1e9;
-constexpr double kMaximumRunTimeSeconds       = 10.0;
 
 struct TraceCategory
 {
@@ -220,7 +219,7 @@ void ANGLEPerfTest::run()
 
     for (uint32_t trial = 0; trial < numTrials; ++trial)
     {
-        doRunLoop(kMaximumRunTimeSeconds, mStepsToRun, RunLoopPolicy::RunContinuously);
+        doRunLoop(gTestTimeSeconds, mStepsToRun, RunLoopPolicy::RunContinuously);
         printResults();
         if (gVerboseLogging)
         {
@@ -386,12 +385,13 @@ double ANGLEPerfTest::normalizedTime(size_t value) const
 
 void ANGLEPerfTest::calibrateStepsToRun()
 {
-    doRunLoop(gTestTimeSeconds, std::numeric_limits<int>::max(), RunLoopPolicy::FinishEveryStep);
+    doRunLoop(gCalibrationTimeSeconds, std::numeric_limits<int>::max(),
+              RunLoopPolicy::FinishEveryStep);
 
     double elapsedTime = mTimer.getElapsedTime();
 
     // Scale steps down according to the time that exeeded one second.
-    double scale = gTestTimeSeconds / elapsedTime;
+    double scale = gCalibrationTimeSeconds / elapsedTime;
     mStepsToRun  = static_cast<unsigned int>(static_cast<double>(mTrialNumStepsPerformed) * scale);
     mStepsToRun  = std::max(1, mStepsToRun);
 
@@ -667,7 +667,7 @@ void ANGLERenderTest::SetUp()
 
     for (int loopIndex = 0; loopIndex < gWarmupLoops; ++loopIndex)
     {
-        doRunLoop(gTestTimeSeconds, std::numeric_limits<int>::max(),
+        doRunLoop(gCalibrationTimeSeconds, std::numeric_limits<int>::max(),
                   RunLoopPolicy::FinishEveryStep);
         if (gVerboseLogging)
         {

src/tests/perf_tests/ANGLEPerfTestArgs.cpp

@@ -13,18 +13,19 @@
 
 namespace angle
 {
-bool gCalibration          = false;
-int gStepsPerTrial         = 0;
-int gMaxStepsPerformed     = 0;
-bool gEnableTrace          = false;
-const char *gTraceFile     = "ANGLETrace.json";
-const char *gScreenShotDir = nullptr;
-bool gVerboseLogging       = false;
-double gTestTimeSeconds    = 1.0;
-int gTestTrials            = 3;
-bool gNoFinish             = false;
-bool gEnableAllTraceTests  = false;
-bool gStartTraceAfterSetup = false;
+bool gCalibration              = false;
+int gStepsPerTrial             = 0;
+int gMaxStepsPerformed         = 0;
+bool gEnableTrace              = false;
+const char *gTraceFile         = "ANGLETrace.json";
+const char *gScreenShotDir     = nullptr;
+bool gVerboseLogging           = false;
+double gCalibrationTimeSeconds = 1.0;
+double gTestTimeSeconds        = 10.0;
+int gTestTrials                = 3;
+bool gNoFinish                 = false;
+bool gEnableAllTraceTests      = false;
+bool gStartTraceAfterSetup     = false;
 
 // Default to three warmup loops. There's no science to this. More than two loops was experimentally
 // helpful on a Windows NVIDIA setup when testing with Vulkan and native trace tests.
@@ -85,6 +86,7 @@ void ANGLEProcessPerfTestArgs(int *argc, char **argv)
             gMaxStepsPerformed = ReadIntArgument(argv[argIndex + 1]);
             gWarmupLoops       = 0;
             gTestTrials        = 1;
+            gTestTimeSeconds   = 36000;
             // Skip an additional argument.
             argIndex++;
         }
@@ -112,6 +114,12 @@ void ANGLEProcessPerfTestArgs(int *argc, char **argv)
         {
             gScreenShotDir = argv[argIndex] + strlen(kRenderTestDirArg);
         }
+        else if (strcmp("--calibration-time", argv[argIndex]) == 0)
+        {
+            gCalibrationTimeSeconds = ReadIntArgument(argv[argIndex + 1]);
+            // Skip an additional argument.
+            argIndex++;
+        }
         else if (strcmp("--test-time", argv[argIndex]) == 0)
         {
             gTestTimeSeconds = ReadIntArgument(argv[argIndex + 1]);

src/tests/perf_tests/ANGLEPerfTestArgs.h

@@ -22,6 +22,7 @@ extern const char *gTraceFile;
 extern const char *gScreenShotDir;
 extern bool gVerboseLogging;
 extern int gWarmupLoops;
+extern double gCalibrationTimeSeconds;
 extern double gTestTimeSeconds;
 extern int gTestTrials;
 extern bool gNoFinish;

src/tests/perf_tests/README.md

@@ -33,7 +33,8 @@ Several command-line arguments control how the tests run:
 * `--verbose`: Print extra timing information.
 * `--warmup-loops x`: Number of times to warm up the test before starting timing. Defaults to 3.
 * `--no-warmup`: Skip warming up the tests. Equivalent to `--warmup-steps 0`.
-* `--test-time`: Run each test trial in a fixed time. Defaults to 1 second.
+* `--calibration-time`: Run each test calibration step in a fixed time. Defaults to 1 second.
+* `--test-time`: Run each test trial in a fixed time. Defaults to 10 seconds.
 * `--trials`: Number of times to repeat testing. Defaults to 3.
 * `--no-finish`: Don't call glFinish after each test trial.
 * `--enable-all-trace-tests`: Offscreen and vsync-limited trace tests are disabled by default to reduce test time.