kc3-lang/angle/src/tests/perf_tests/EGLInitializePerf.cpp

• Show log

  Commit

• Hash : 8047f065
  Author :
  Date : 2015-12-15T17:54:42
  

  Improve perf testing framework
  
  The ANGLERenderTest subclasses have a parameter "iterations". Previously
  most of these tests would perform iterations^2 iterations, since the
  looping was done both in ANGLERenderTest and in the individual test
  classes. Do the looping only in the individual test classes instead.
  This enables getting rid of separate beginDrawBenchmark() and
  endDrawBenchmark() functions.
  
  Some other unused code is also removed:
  
  1. stepBenchmark function
  2. unused parameters to step()
  
  This makes the core loop of running tests simpler.
  
  The perf testing framework also now has shared logic for deciding when
  to end a given test.
  
  The score calculation for tests is also changed. Instead of reporting
  just the number of operations done, it is reported relative to the actual
  run time of the test. This should make the test results more accurate,
  since run time of the tests may have some variation. It also enables
  changing the run time of the tests without rebaselining them.
  
  In the tests that use GPU, GPU operations are also waited to finish
  before stopping the timer.
  
  BUG=angleproject:1261
  TEST=angle_perftests
  
  Change-Id: I69e9aad8afd2d9dedd60e144f0a5d4203618feef
  Reviewed-on: https://chromium-review.googlesource.com/319381
  Tryjob-Request: Olli Etuaho <oetuaho@nvidia.com>
  Tested-by: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Zhenyao Mo <zmo@chromium.org>
  

Download

• src/tests/perf_tests/EGLInitializePerf.cpp

• //
  // Copyright 2015 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.
  //
  // EGLInitializePerfTest:
  //   Performance test for device creation.
  //
  
  #include "ANGLEPerfTest.h"
  #include "Timer.h"
  #include "test_utils/angle_test_configs.h"
  #include "test_utils/angle_test_instantiate.h"
  #include "platform/Platform.h"
  
  using namespace testing;
  
  namespace
  {
  
  // Only applies to D3D11
  class CapturePlatform : public angle::Platform
  {
    public:
      CapturePlatform()
          : mTimer(CreateTimer()),
            mLoadDLLsMS(0),
            mCreateDeviceMS(0),
            mInitResourcesMS(0)
      {
          mTimer->start();
      }
  
      double currentTime() override;
      void histogramCustomCounts(
          const char *name, int sample, int min, int max, int bucketCount) override;
  
      size_t getLoadDLLsMS() const { return mLoadDLLsMS; }
      size_t getCreateDeviceMS() const { return mCreateDeviceMS; }
      size_t getInitResourcesMS() const { return mInitResourcesMS; }
  
    private:
      Timer *mTimer;
      size_t mLoadDLLsMS;
      size_t mCreateDeviceMS;
      size_t mInitResourcesMS;
  };
  
  double CapturePlatform::currentTime()
  {
      return mTimer->getElapsedTime();
  }
  
  void CapturePlatform::histogramCustomCounts(
      const char *name, int sample, int /*min*/, int /*max*/, int /*bucketCount*/)
  {
      // These must match the names of the histograms.
      if (strcmp(name, "GPU.ANGLE.Renderer11InitializeDLLsMS") == 0)
      {
          mLoadDLLsMS += static_cast<size_t>(sample);
      }
      // Note: not captured in debug, due to creating a debug device
      else if (strcmp(name, "GPU.ANGLE.D3D11CreateDeviceMS") == 0)
      {
          mCreateDeviceMS += static_cast<size_t>(sample);
      }
      else if (strcmp(name, "GPU.ANGLE.Renderer11InitializeDeviceMS") == 0)
      {
          mInitResourcesMS += static_cast<size_t>(sample);
      }
  }
  
  class EGLInitializePerfTest : public ANGLEPerfTest,
                                public WithParamInterface<angle::PlatformParameters>
  {
    public:
      EGLInitializePerfTest();
      ~EGLInitializePerfTest();
  
      void step() override;
      void TearDown() override;
  
    private:
      OSWindow *mOSWindow;
      EGLDisplay mDisplay;
      CapturePlatform mCapturePlatform;
  };
  
  EGLInitializePerfTest::EGLInitializePerfTest()
      : ANGLEPerfTest("EGLInitialize", "_run"),
        mOSWindow(nullptr),
        mDisplay(EGL_NO_DISPLAY)
  {
      auto platform = GetParam().eglParameters;
  
      std::vector<EGLint> displayAttributes;
      displayAttributes.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
      displayAttributes.push_back(platform.renderer);
      displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE);
      displayAttributes.push_back(platform.majorVersion);
      displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE);
      displayAttributes.push_back(platform.minorVersion);
  
      if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE ||
          platform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
      {
          displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
          displayAttributes.push_back(platform.deviceType);
      }
      displayAttributes.push_back(EGL_NONE);
  
      mOSWindow = CreateOSWindow();
      mOSWindow->initialize("EGLInitialize Test", 64, 64);
  
      auto eglGetPlatformDisplayEXT =
          reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(eglGetProcAddress("eglGetPlatformDisplayEXT"));
      if (eglGetPlatformDisplayEXT == nullptr)
      {
          std::cerr << "Error getting platform display!" << std::endl;
          return;
      }
  
      mDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,
                                          mOSWindow->getNativeDisplay(),
                                          &displayAttributes[0]);
  
      ANGLEPlatformInitialize(&mCapturePlatform);
  }
  
  EGLInitializePerfTest::~EGLInitializePerfTest()
  {
      SafeDelete(mOSWindow);
  }
  
  void EGLInitializePerfTest::step()
  {
      ASSERT_NE(EGL_NO_DISPLAY, mDisplay);
  
      EGLint majorVersion, minorVersion;
      ASSERT_EQ(static_cast<EGLBoolean>(EGL_TRUE), eglInitialize(mDisplay, &majorVersion, &minorVersion));
      ASSERT_EQ(static_cast<EGLBoolean>(EGL_TRUE), eglTerminate(mDisplay));
  }
  
  void EGLInitializePerfTest::TearDown()
  {
      ANGLEPerfTest::TearDown();
      printResult("LoadDLLs", normalizedTime(mCapturePlatform.getLoadDLLsMS()), "ms", true);
      printResult("D3D11CreateDevice", normalizedTime(mCapturePlatform.getCreateDeviceMS()), "ms", true);
      printResult("InitResources", normalizedTime(mCapturePlatform.getInitResourcesMS()), "ms", true);
  
      ANGLEPlatformShutdown();
  }
  
  TEST_P(EGLInitializePerfTest, Run)
  {
      run();
  }
  
  ANGLE_INSTANTIATE_TEST(EGLInitializePerfTest, angle::ES2_D3D11());
  
  } // namespace
  

Download