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

• Show log

  Commit

• Hash : 3402d523
  Author :
  Date : 2018-10-30T15:14:52
  

  Try to reduce variance in angle_perftests.
  
  This change does a few things:
  
  - make perf test runner script print % variation instead of stddev
  
  This makes it a bit more clear how much variance there is.
  
  - stabilize CPU in the render perf tests
  
  Setting a thread affinity and priority should stop from switching cores
  during the run. Hopefully can prevent background noise from changing
  the test results.
  
  - warm up the benchmark with a few iterations
  
  This should hopefully make the test results a bit more stable.
  
  - output a new normalized perf result value
  
  The new result is normalized against the number of iterations. So it
  should hopefully be stable even if the number of iterations is changed.
  
  - increases the iteration count in the draw call perf tests.
  
  These tests were completely dominated by SwapBuffers time. Increasing
  the iterations per step means we actually are bottlenecked on CPU time
  instead.
  
  Bug: angleproject:2923
  Change-Id: I5ee347cf93df239ac33b83dc5effe4c21e066736
  Reviewed-on: https://chromium-review.googlesource.com/c/1303679
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@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)
  
  // These are trace events according to Google's "Trace Event Format".
  // See https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU
  // Only a subset of the properties are implemented.
  struct TraceEvent final
  {
      TraceEvent() {}
  
      TraceEvent(char phaseIn, const char *categoryNameIn, const char *nameIn, double timestampIn)
          : phase(phaseIn), categoryName(categoryNameIn), name(nameIn), timestamp(timestampIn)
      {
      }
  
      char phase       = 0;
      const char *categoryName = nullptr;
      const char *name = nullptr;
      double timestamp = 0;
  };
  
  class ANGLEPerfTest : public testing::Test, angle::NonCopyable
  {
    public:
      ANGLEPerfTest(const std::string &name,
                    const std::string &suffix,
                    unsigned int iterationsPerStep);
      virtual ~ANGLEPerfTest();
  
      virtual void step() = 0;
  
      // Called right before timer is stopped to let the test wait for asynchronous operations.
      virtual void finishTest() {}
  
      Timer *getTimer() const { return mTimer; }
  
    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;
      unsigned int mIterationsPerStep;
      bool mRunning;
  };
  
  struct RenderTestParams : public angle::PlatformParameters
  {
      virtual std::string suffix() const;
  
      EGLint windowWidth  = 64;
      EGLint windowHeight = 64;
      unsigned int iterationsPerStep = 0;
  };
  
  class ANGLERenderTest : public ANGLEPerfTest
  {
    public:
      ANGLERenderTest(const std::string &name, const RenderTestParams &testParams);
      ~ANGLERenderTest();
  
      void addExtensionPrerequisite(const char *extensionName);
  
      virtual void initializeBenchmark() { }
      virtual void destroyBenchmark() { }
  
      virtual void drawBenchmark() = 0;
  
      bool popEvent(Event *event);
  
      OSWindow *getWindow();
  
      std::vector<TraceEvent> &getTraceEventBuffer();
  
      virtual void overrideWorkaroundsD3D(angle::WorkaroundsD3D *workaroundsD3D) {}
  
    protected:
      const RenderTestParams &mTestParams;
  
      void setWebGLCompatibilityEnabled(bool webglCompatibility);
      void setRobustResourceInit(bool enabled);
  
    private:
      void SetUp() override;
      void TearDown() override;
  
      void step() override;
      void finishTest() override;
  
      bool areExtensionPrerequisitesFulfilled() const;
  
      static EGLWindow *createEGLWindow(const RenderTestParams &testParams);
  
      EGLWindow *mEGLWindow;
      OSWindow *mOSWindow;
      std::vector<const char *> mExtensionPrerequisites;
      angle::PlatformMethods mPlatformMethods;
  
      // Trace event record that can be output.
      std::vector<TraceEvent> mTraceEventBuffer;
  };
  
  extern bool g_OnlyOneRunFrame;
  
  #endif // PERF_TESTS_ANGLE_PERF_TEST_H_
  

Download