Split ANGLEPerfTest into a Render and basic test.

src/tests/perf_tests/ANGLEPerfTest.cpp

@@ -11,7 +11,63 @@
 #include <iostream>
 #include <cassert>
 
-std::string PerfTestParams::suffix() const
+ANGLEPerfTest::ANGLEPerfTest(const std::string &name, const std::string &suffix)
+    : mName(name),
+      mSuffix(suffix),
+      mRunning(false),
+      mNumFrames(0)
+{
+    mTimer.reset(CreateTimer());
+}
+
+void ANGLEPerfTest::run()
+{
+    mTimer->start();
+    double prevTime = 0.0;
+
+    while (mRunning)
+    {
+        double elapsedTime = mTimer->getElapsedTime();
+        double deltaTime = elapsedTime - prevTime;
+
+        ++mNumFrames;
+        step(static_cast<float>(deltaTime), elapsedTime);
+
+        if (!mRunning)
+        {
+            break;
+        }
+
+        prevTime = elapsedTime;
+    }
+}
+
+void ANGLEPerfTest::printResult(const std::string &trace, double value, const std::string &units, bool important) const
+{
+    perf_test::PrintResult(mName, mSuffix, trace, value, units, important);
+}
+
+void ANGLEPerfTest::printResult(const std::string &trace, size_t value, const std::string &units, bool important) const
+{
+    perf_test::PrintResult(mName, mSuffix, trace, value, units, important);
+}
+
+void ANGLEPerfTest::SetUp()
+{
+    mRunning = true;
+}
+
+void ANGLEPerfTest::TearDown()
+{
+    double totalTime = mTimer->getElapsedTime();
+    double averageTime = 1000.0 * totalTime / static_cast<double>(mNumFrames);
+
+    printResult("total_time", totalTime, "s", true);
+    printResult("frames", static_cast<size_t>(mNumFrames), "frames", true);
+    printResult("average_time", averageTime, "ms", true);
+}
+
+std::string RenderTestParams::suffix() const
 {
     switch (requestedRenderer)
     {
@@ -21,18 +77,15 @@ std::string PerfTestParams::suffix() const
     }
 }
 
-ANGLEPerfTest::ANGLEPerfTest(const std::string &name, const PerfTestParams &testParams)
-    : mTestParams(testParams),
-      mNumFrames(0),
-      mName(name),
-      mRunning(false),
-      mSuffix(testParams.suffix()),
+ANGLERenderTest::ANGLERenderTest(const std::string &name, const RenderTestParams &testParams)
+    : ANGLEPerfTest(name, testParams.suffix()),
+      mTestParams(testParams),
       mDrawIterations(10),
       mRunTimeSeconds(5.0)
 {
 }
 
-void ANGLEPerfTest::SetUp()
+void ANGLERenderTest::SetUp()
 {
     EGLPlatformParameters platformParams(mTestParams.requestedRenderer,
                                          EGL_DONT_CARE,
@@ -44,7 +97,6 @@ void ANGLEPerfTest::SetUp()
                                    mTestParams.windowHeight,
                                    mTestParams.glesMajorVersion,
                                    platformParams));
-    mTimer.reset(CreateTimer());
 
     if (!mOSWindow->initialize(mName, mEGLWindow->getWidth(), mEGLWindow->getHeight()))
     {
@@ -64,27 +116,12 @@ void ANGLEPerfTest::SetUp()
         return;
     }
 
-    mRunning = true;
+    ANGLEPerfTest::SetUp();
 }
 
-void ANGLEPerfTest::printResult(const std::string &trace, double value, const std::string &units, bool important) const
+void ANGLERenderTest::TearDown()
 {
-    perf_test::PrintResult(mName, mSuffix, trace, value, units, important);
-}
-
-void ANGLEPerfTest::printResult(const std::string &trace, size_t value, const std::string &units, bool important) const
-{
-    perf_test::PrintResult(mName, mSuffix, trace, value, units, important);
-}
-
-void ANGLEPerfTest::TearDown()
-{
-    double totalTime = mTimer->getElapsedTime();
-    double averageTime = 1000.0 * totalTime / static_cast<double>(mNumFrames);
-
-    printResult("total_time", totalTime, "s", true);
-    printResult("frames", static_cast<size_t>(mNumFrames), "frames", true);
-    printResult("average_time", averageTime, "ms", true);
+    ANGLEPerfTest::TearDown();
 
     destroyBenchmark();
 
@@ -92,14 +129,33 @@ void ANGLEPerfTest::TearDown()
     mOSWindow->destroy();
 }
 
-void ANGLEPerfTest::step(float dt, double totalTime)
+void ANGLERenderTest::step(float dt, double totalTime)
 {
     stepBenchmark(dt, totalTime);
+
+    // Clear events that the application did not process from this frame
+    Event event;
+    while (popEvent(&event))
+    {
+        // If the application did not catch a close event, close now
+        if (event.Type == Event::EVENT_CLOSED)
+        {
+            mRunning = false;
+        }
+    }
+
+    if (mRunning)
+    {
+        draw();
+        mEGLWindow->swap();
+        mOSWindow->messageLoop();
+    }
 }
 
-void ANGLEPerfTest::draw()
+void ANGLERenderTest::draw()
 {
-    if (mTimer->getElapsedTime() > mRunTimeSeconds) {
+    if (mTimer->getElapsedTime() > mRunTimeSeconds)
+    {
         mRunning = false;
         return;
     }
@@ -116,49 +172,12 @@ void ANGLEPerfTest::draw()
     endDrawBenchmark();
 }
 
-void ANGLEPerfTest::run()
-{
-    mTimer->start();
-    double prevTime = 0.0;
-
-    while (mRunning)
-    {
-        double elapsedTime = mTimer->getElapsedTime();
-        double deltaTime = elapsedTime - prevTime;
-
-        step(static_cast<float>(deltaTime), elapsedTime);
-
-        // Clear events that the application did not process from this frame
-        Event event;
-        while (popEvent(&event))
-        {
-            // If the application did not catch a close event, close now
-            if (event.Type == Event::EVENT_CLOSED)
-            {
-                mRunning = false;
-            }
-        }
-
-        if (!mRunning)
-        {
-            break;
-        }
-
-        draw();
-        mEGLWindow->swap();
-
-        mOSWindow->messageLoop();
-
-        prevTime = elapsedTime;
-    }
-}
-
-bool ANGLEPerfTest::popEvent(Event *event)
+bool ANGLERenderTest::popEvent(Event *event)
 {
     return mOSWindow->popEvent(event);
 }
 
-OSWindow *ANGLEPerfTest::getWindow()
+OSWindow *ANGLERenderTest::getWindow()
 {
     return mOSWindow.get();
 }

src/tests/perf_tests/ANGLEPerfTest.h

@@ -24,23 +24,46 @@
 
 class Event;
 
-struct PerfTestParams
+class ANGLEPerfTest : public testing::Test
 {
+  public:
+    ANGLEPerfTest(const std::string &name, const std::string &suffix);
+    virtual ~ANGLEPerfTest() { };
+
+    virtual void step(float dt, double totalTime) = 0;
+
+    DISALLOW_COPY_AND_ASSIGN(ANGLEPerfTest);
+
+  protected:
+    void run();
+    void printResult(const std::string &trace, double value, const std::string &units, bool important) const;
+    void printResult(const std::string &trace, size_t value, const std::string &units, bool important) const;
+    void SetUp() override;
+    void TearDown() override;
+
+    std::string mName;
+    std::string mSuffix;
+
+    bool mRunning;
+    std::unique_ptr<Timer> mTimer;
+    int mNumFrames;
+};
+
+struct RenderTestParams
+{
+    virtual std::string suffix() const;
+
     EGLint requestedRenderer;
     EGLint deviceType;
     EGLint glesMajorVersion;
     EGLint widowWidth;
     EGLint windowHeight;
-
-    virtual std::string suffix() const;
 };
 
-class ANGLEPerfTest : public testing::Test
+class ANGLERenderTest : public ANGLEPerfTest
 {
   public:
-    ANGLEPerfTest(const std::string &name, const PerfTestParams &testParams);
-
-    virtual ~ANGLEPerfTest() { };
+    ANGLERenderTest(const std::string &name, const RenderTestParams &testParams);
 
     virtual bool initializeBenchmark() { return true; }
     virtual void destroyBenchmark() { }
@@ -56,31 +79,21 @@ class ANGLEPerfTest : public testing::Test
     OSWindow *getWindow();
 
   protected:
-    void printResult(const std::string &trace, double value, const std::string &units, bool important) const;
-    void printResult(const std::string &trace, size_t value, const std::string &units, bool important) const;
-    void run();
-
-    const PerfTestParams &mTestParams;
+    const RenderTestParams &mTestParams;
     unsigned int mDrawIterations;
     double mRunTimeSeconds;
-    int mNumFrames;
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(ANGLEPerfTest);
+    DISALLOW_COPY_AND_ASSIGN(ANGLERenderTest);
 
     void SetUp() override;
     void TearDown() override;
 
-    void step(float dt, double totalTime);
+    void step(float dt, double totalTime) override;
     void draw();
 
-    std::string mName;
-    bool mRunning;
-    std::string mSuffix;
-
     std::unique_ptr<EGLWindow> mEGLWindow;
     std::unique_ptr<OSWindow> mOSWindow;
-    std::unique_ptr<Timer> mTimer;
 };
 
 #endif // PERF_TESTS_ANGLE_PERF_TEST_H_

src/tests/perf_tests/BufferSubData.cpp

@@ -16,7 +16,7 @@
 namespace
 {
 
-struct BufferSubDataParams final : public PerfTestParams
+struct BufferSubDataParams final : public RenderTestParams
 {
     std::string suffix() const override;
 
@@ -31,7 +31,7 @@ struct BufferSubDataParams final : public PerfTestParams
     unsigned int iterations;
 };
 
-class BufferSubDataBenchmark : public ANGLEPerfTest,
+class BufferSubDataBenchmark : public ANGLERenderTest,
                                public ::testing::WithParamInterface<BufferSubDataParams>
 {
   public:
@@ -165,7 +165,7 @@ std::string BufferSubDataParams::suffix() const
 {
     std::stringstream strstr;
 
-    strstr << PerfTestParams::suffix();
+    strstr << RenderTestParams::suffix();
 
     if (vertexNormalized)
     {
@@ -191,7 +191,7 @@ std::string BufferSubDataParams::suffix() const
 }
 
 BufferSubDataBenchmark::BufferSubDataBenchmark()
-    : ANGLEPerfTest("BufferSubData", GetParam()),
+    : ANGLERenderTest("BufferSubData", GetParam()),
       mProgram(0),
       mBuffer(0),
       mUpdateData(NULL),

src/tests/perf_tests/PointSprites.cpp

@@ -18,7 +18,7 @@
 namespace
 {
 
-struct PointSpritesParams final : public PerfTestParams
+struct PointSpritesParams final : public RenderTestParams
 {
     std::string suffix() const override;
 
@@ -30,7 +30,7 @@ struct PointSpritesParams final : public PerfTestParams
     unsigned int iterations;
 };
 
-class PointSpritesBenchmark : public ANGLEPerfTest,
+class PointSpritesBenchmark : public ANGLERenderTest,
                               public ::testing::WithParamInterface<PointSpritesParams>
 {
   public:
@@ -52,7 +52,7 @@ std::string PointSpritesParams::suffix() const
 {
     std::stringstream strstr;
 
-    strstr << PerfTestParams::suffix()
+    strstr << RenderTestParams::suffix()
            << "_" << count << "_" << size << "px"
            << "_" << numVaryings << "vars";
 
@@ -60,7 +60,7 @@ std::string PointSpritesParams::suffix() const
 }
 
 PointSpritesBenchmark::PointSpritesBenchmark()
-    : ANGLEPerfTest("PointSprites", GetParam())
+    : ANGLERenderTest("PointSprites", GetParam())
 {
 }
 

src/tests/perf_tests/TexSubImage.cpp

@@ -16,7 +16,7 @@
 namespace
 {
 
-struct TexSubImageParams final : public PerfTestParams
+struct TexSubImageParams final : public RenderTestParams
 {
     std::string suffix() const override;
 
@@ -28,7 +28,7 @@ struct TexSubImageParams final : public PerfTestParams
     unsigned int iterations;
 };
 
-class TexSubImageBenchmark : public ANGLEPerfTest,
+class TexSubImageBenchmark : public ANGLERenderTest,
                              public ::testing::WithParamInterface<TexSubImageParams>
 {
   public:
@@ -66,11 +66,11 @@ class TexSubImageBenchmark : public ANGLEPerfTest,
 std::string TexSubImageParams::suffix() const
 {
     // TODO(jmadill)
-    return PerfTestParams::suffix();
+    return RenderTestParams::suffix();
 }
 
 TexSubImageBenchmark::TexSubImageBenchmark()
-    : ANGLEPerfTest("TexSubImage", GetParam()),
+    : ANGLERenderTest("TexSubImage", GetParam()),
       mProgram(0),
       mPositionLoc(-1),
       mTexCoordLoc(-1),