Perf Tests: Fix trace test calibration.

src/tests/perf_tests/ANGLEPerfTest.cpp

@@ -188,7 +188,7 @@ ANGLEPerfTest::ANGLEPerfTest(const std::string &name,
       mStory(story),
       mGPUTimeNs(0),
       mSkipTest(false),
-      mStepsToRun(std::numeric_limits<unsigned int>::max()),
+      mStepsToRun(gStepsToRunOverride),
       mNumStepsPerformed(0),
       mIterationsPerStep(iterationsPerStep),
       mRunning(true)
@@ -217,24 +217,9 @@ void ANGLEPerfTest::run()
     }
 
     // Calibrate to a fixed number of steps during an initial set time.
-    if (gStepsToRunOverride <= 0)
+    if (mStepsToRun <= 0)
     {
-        doRunLoop(kCalibrationRunTimeSeconds);
-
-        // Scale steps down according to the time that exeeded one second.
-        double scale = kCalibrationRunTimeSeconds / mTimer.getElapsedTime();
-        mStepsToRun  = static_cast<unsigned int>(static_cast<double>(mNumStepsPerformed) * scale);
-
-        // Calibration allows the perf test runner script to save some time.
-        if (gCalibration)
-        {
-            mReporter->AddResult(".steps", static_cast<size_t>(mStepsToRun));
-            return;
-        }
-    }
-    else
-    {
-        mStepsToRun = gStepsToRunOverride;
+        calibrateStepsToRun();
     }
 
     // Check again for early exit.
@@ -246,11 +231,14 @@ void ANGLEPerfTest::run()
     // Do another warmup run. Seems to consistently improve results.
     doRunLoop(kMaximumRunTimeSeconds);
 
-    double totalTime = 0.0;
     for (unsigned int trial = 0; trial < kNumTrials; ++trial)
     {
         doRunLoop(kMaximumRunTimeSeconds);
-        totalTime += printResults();
+        printResults();
+        if (gVerboseLogging)
+        {
+            printf("Trial %d time: %.2lf seconds.\n", trial + 1, mTimer.getElapsedTime());
+        }
     }
 }
 
@@ -338,6 +326,45 @@ double ANGLEPerfTest::normalizedTime(size_t value) const
     return static_cast<double>(value) / static_cast<double>(mNumStepsPerformed);
 }
 
+void ANGLEPerfTest::calibrateStepsToRun()
+{
+    // First do two warmup loops. There's no science to this. Two loops was experimentally helpful
+    // on a Windows NVIDIA setup when testing with Vulkan and native trace tests.
+    for (int i = 0; i < 2; ++i)
+    {
+        doRunLoop(kCalibrationRunTimeSeconds);
+        if (gVerboseLogging)
+        {
+            printf("Pre-calibration warm-up took %.2lf seconds.\n", mTimer.getElapsedTime());
+        }
+    }
+
+    // Now the real computation.
+    doRunLoop(kCalibrationRunTimeSeconds);
+
+    double elapsedTime = mTimer.getElapsedTime();
+
+    // Scale steps down according to the time that exeeded one second.
+    double scale = kCalibrationRunTimeSeconds / elapsedTime;
+    mStepsToRun  = static_cast<unsigned int>(static_cast<double>(mNumStepsPerformed) * scale);
+
+    if (gVerboseLogging)
+    {
+        printf(
+            "Running %d steps (calibration took %.2lf seconds). Expecting trial time of %.2lf "
+            "seconds.\n",
+            mStepsToRun, elapsedTime,
+            mStepsToRun * (elapsedTime / static_cast<double>(mNumStepsPerformed)));
+    }
+
+    // Calibration allows the perf test runner script to save some time.
+    if (gCalibration)
+    {
+        mReporter->AddResult(".steps", static_cast<size_t>(mStepsToRun));
+        return;
+    }
+}
+
 std::string RenderTestParams::backend() const
 {
     std::stringstream strstr;
@@ -579,6 +606,11 @@ void ANGLERenderTest::SetUp()
         std::string screenshotName = screenshotNameStr.str();
         saveScreenshot(screenshotName);
     }
+
+    if (mStepsToRun <= 0)
+    {
+        calibrateStepsToRun();
+    }
 }
 
 void ANGLERenderTest::TearDown()

src/tests/perf_tests/ANGLEPerfTest.h

@@ -88,6 +88,9 @@ class ANGLEPerfTest : public testing::Test, angle::NonCopyable
     // Overriden in trace perf tests.
     virtual void saveScreenshot(const std::string &screenshotName) {}
 
+    double printResults();
+    void calibrateStepsToRun();
+
     std::string mName;
     std::string mBackend;
     std::string mStory;
@@ -95,13 +98,9 @@ class ANGLEPerfTest : public testing::Test, angle::NonCopyable
     uint64_t mGPUTimeNs;
     bool mSkipTest;
     std::unique_ptr<perf_test::PerfResultReporter> mReporter;
-
-  private:
-    double printResults();
-
-    unsigned int mStepsToRun;
-    unsigned int mNumStepsPerformed;
-    unsigned int mIterationsPerStep;
+    int mStepsToRun;
+    int mNumStepsPerformed;
+    int mIterationsPerStep;
     bool mRunning;
 };
 

src/tests/perf_tests/ANGLEPerfTestArgs.cpp

@@ -18,6 +18,7 @@ int gStepsToRunOverride    = -1;
 bool gEnableTrace          = false;
 const char *gTraceFile     = "ANGLETrace.json";
 const char *gScreenShotDir = nullptr;
+bool gVerboseLogging       = false;
 }  // namespace angle
 
 using namespace angle;
@@ -61,6 +62,10 @@ void ANGLEProcessPerfTestArgs(int *argc, char **argv)
             gScreenShotDir = argv[argIndex + 1];
             argIndex++;
         }
+        else if (strcmp("--verbose-logging", argv[argIndex]) == 0)
+        {
+            gVerboseLogging = true;
+        }
         else
         {
             argv[argcOutCount++] = argv[argIndex];

src/tests/perf_tests/ANGLEPerfTestArgs.h

@@ -19,6 +19,7 @@ extern int gStepsToRunOverride;
 extern bool gEnableTrace;
 extern const char *gTraceFile;
 extern const char *gScreenShotDir;
+extern bool gVerboseLogging;
 
 inline bool OneFrame()
 {