kc3-lang/angle/src/tests/perf_tests/ANGLEPerfTest.h

• Show log

  Commit

• Hash : 981f0f8f
  Author :
  Date : 2017-09-21T09:07:41
  

  Add flag to do a fast pass through perf tests.
  
  This flag will only render the first frame of each perf test,
  regardless of their preferences for how many seconds to run.
  It will be useful for speeding up the run time of the perf tests
  on testing infrastructure that only cares about correctness.
  
  BUG=chromium:725308
  BUG=chromium:765321
  
  Change-Id: I926f488c42f27ef23ef06a0159902613cff04080
  Reviewed-on: https://chromium-review.googlesource.com/677306
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/tests/perf_tests/ANGLEPerfTest.h

• //
  // Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // ANGLEPerfTests:
  //   Base class for google test performance tests
  //
  
  #ifndef PERF_TESTS_ANGLE_PERF_TEST_H_
  #define PERF_TESTS_ANGLE_PERF_TEST_H_
  
  #include <string>
  #include <vector>
  
  #include <gtest/gtest.h>
  #include <EGL/egl.h>
  #include <EGL/eglext.h>
  
  #include "EGLWindow.h"
  #include "OSWindow.h"
  #include "Timer.h"
  #include "common/angleutils.h"
  #include "common/debug.h"
  #include "platform/Platform.h"
  #include "test_utils/angle_test_configs.h"
  #include "test_utils/angle_test_instantiate.h"
  
  class Event;
  
  #if !defined(ASSERT_GL_NO_ERROR)
  #define ASSERT_GL_NO_ERROR() ASSERT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError())
  #endif  // !defined(ASSERT_GL_NO_ERROR)
  
  #if !defined(ASSERT_GLENUM_EQ)
  #define ASSERT_GLENUM_EQ(expected, actual) \
      ASSERT_EQ(static_cast<GLenum>(expected), static_cast<GLenum>(actual))
  #endif  // !defined(ASSERT_GLENUM_EQ)
  
  class ANGLEPerfTest : public testing::Test, angle::NonCopyable
  {
    public:
      ANGLEPerfTest(const std::string &name, const std::string &suffix);
      virtual ~ANGLEPerfTest();
  
      virtual void step() = 0;
  
      // Called right before timer is stopped to let the test wait for asynchronous operations.
      virtual void finishTest() {}
  
    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;
  
      // Normalize a time value according to the number of test loop iterations (mFrameCount)
      double normalizedTime(size_t value) const;
  
      // Call if the test step was aborted and the test should stop running.
      void abortTest() { mRunning = false; }
  
      unsigned int getNumStepsPerformed() const { return mNumStepsPerformed; }
  
      std::string mName;
      std::string mSuffix;
      Timer *mTimer;
      double mRunTimeSeconds;
      bool mSkipTest;
  
    private:
      unsigned int mNumStepsPerformed;
      bool mRunning;
  };
  
  struct RenderTestParams : public angle::PlatformParameters
  {
      virtual std::string suffix() const;
  
      EGLint windowWidth;
      EGLint windowHeight;
  };
  
  class ANGLERenderTest : public ANGLEPerfTest
  {
    public:
      ANGLERenderTest(const std::string &name, const RenderTestParams &testParams);
      ANGLERenderTest(const std::string &name,
                      const RenderTestParams &testParams,
                      const std::vector<std::string> &extensionPrerequisites);
      ~ANGLERenderTest();
  
      virtual void initializeBenchmark() { }
      virtual void destroyBenchmark() { }
  
      virtual void drawBenchmark() = 0;
  
      bool popEvent(Event *event);
  
      OSWindow *getWindow();
  
      virtual void overrideWorkaroundsD3D(angle::WorkaroundsD3D *workaroundsD3D) {}
  
    protected:
      const RenderTestParams &mTestParams;
  
    private:
      void SetUp() override;
      void TearDown() override;
  
      void step() override;
      void finishTest() override;
  
      bool areExtensionPrerequisitesFulfilled() const;
  
      EGLWindow *mEGLWindow;
      OSWindow *mOSWindow;
      std::vector<std::string> mExtensionPrerequisites;
      angle::PlatformMethods mPlatformMethods;
  };
  
  extern bool g_OnlyOneRunFrame;
  
  #endif // PERF_TESTS_ANGLE_PERF_TEST_H_
  

Download