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

• Show log

  Commit

• Hash : c2493e38
  Author :
  Date : 2017-06-20T17:16:25
  

  Add DrawElementsPerf test
  
  This is a follow-up CL for
  https://chromium-review.googlesource.com/c/544634/.
  In this commit, we add drawElements perf test for d3d9, d3d11 and
  OpenGL. Specially, we test DrawElements with unchanged index buffer
  every frame and changed index buffer every frame. This is also a
  preparation for further remove IndexRange in validation.
  Paste a set of data (repeated 30) for reference on Intel skylake
  Win10 desktop.
  DrawElementsPerfBenchmark.Run/d3d11:
  mean: 13186.1666667, stddev: 200.479605502,
  truncated mean: 13192.5416667, stddev: 156.284190704
  DrawElementsPerfBenchmark.Run/d3d11_index_buffer_changed:
  mean: 43.6, stddev: 4.02160830183,
  truncated mean: 43.5833333333, stddev: 2.97092391166
  
  BUG=angleproject:1393
  TEST=angle_perftests
  
  Change-Id: I94bd181aa2b4515df1affc79f591f5db399feac3
  Reviewed-on: https://chromium-review.googlesource.com/585981
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/tests/perf_tests/DrawElementsPerf.cpp

• //
  // Copyright (c) 2017 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.
  //
  // DrawElementsPerf:
  //   Performance tests for ANGLE DrawElements call overhead.
  //
  
  #include <sstream>
  
  #include "ANGLEPerfTest.h"
  #include "DrawCallPerfParams.h"
  #include "test_utils/draw_call_perf_utils.h"
  
  namespace
  {
  
  GLuint CreateElementArrayBuffer(size_t count, GLenum type, GLenum usage)
  {
      GLuint buffer = 0u;
      glGenBuffers(1, &buffer);
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
      glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(type), nullptr, usage);
  
      return buffer;
  }
  
  struct DrawElementsPerfParams final : public DrawCallPerfParams
  {
      // Common default options
      DrawElementsPerfParams()
      {
          runTimeSeconds = 5.0;
          numTris        = 2;
      }
  
      std::string suffix() const override
      {
          std::stringstream strstr;
  
          strstr << DrawCallPerfParams::suffix();
  
          if (indexBufferChanged)
          {
              strstr << "_index_buffer_changed";
          }
  
          return strstr.str();
      }
  
      GLenum type             = GL_UNSIGNED_INT;
      bool indexBufferChanged = false;
  };
  
  std::ostream &operator<<(std::ostream &os, const DrawElementsPerfParams &params)
  {
      os << params.suffix().substr(1);
      return os;
  }
  
  class DrawElementsPerfBenchmark : public ANGLERenderTest,
                                    public ::testing::WithParamInterface<DrawElementsPerfParams>
  {
    public:
      DrawElementsPerfBenchmark();
  
      void initializeBenchmark() override;
      void destroyBenchmark() override;
      void drawBenchmark() override;
  
    private:
      GLuint mProgram     = 0;
      GLuint mBuffer      = 0;
      GLuint mIndexBuffer = 0;
      GLuint mFBO         = 0;
      GLuint mTexture     = 0;
      int mCount          = 3 * GetParam().numTris;
      std::vector<GLuint> mIndexData;
  };
  
  DrawElementsPerfBenchmark::DrawElementsPerfBenchmark()
      : ANGLERenderTest("DrawElementsPerf", GetParam())
  {
      mRunTimeSeconds = GetParam().runTimeSeconds;
  }
  
  void DrawElementsPerfBenchmark::initializeBenchmark()
  {
      const auto &params = GetParam();
  
      ASSERT_LT(0u, params.iterations);
  
      mProgram = SetupSimpleDrawProgram();
      ASSERT_NE(0u, mProgram);
  
      glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  
      mBuffer      = Create2DTriangleBuffer(params.numTris, GL_STATIC_DRAW);
      mIndexBuffer = CreateElementArrayBuffer(mCount, params.type, GL_STATIC_DRAW);
  
      for (int i = 0; i < mCount; i++)
      {
          mIndexData.push_back(rand() % mCount);
      }
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
      glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(params.type) * mIndexData.size(),
                      mIndexData.data());
  
      glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(0);
  
      // Set the viewport
      glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
  
      if (params.useFBO)
      {
          CreateColorFBO(getWindow()->getWidth(), getWindow()->getHeight(), &mTexture, &mFBO);
      }
  
      ASSERT_GL_NO_ERROR();
  }
  
  void DrawElementsPerfBenchmark::destroyBenchmark()
  {
      glDeleteProgram(mProgram);
      glDeleteBuffers(1, &mBuffer);
      glDeleteBuffers(1, &mIndexBuffer);
      glDeleteTextures(1, &mTexture);
      glDeleteFramebuffers(1, &mFBO);
  }
  
  void DrawElementsPerfBenchmark::drawBenchmark()
  {
      // This workaround fixes a huge queue of graphics commands accumulating on the GL
      // back-end. The GL back-end doesn't have a proper NULL device at the moment.
      // TODO(jmadill): Remove this when/if we ever get a proper OpenGL NULL device.
      const auto &eglParams = GetParam().eglParameters;
      if (eglParams.deviceType != EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE ||
          (eglParams.renderer != EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE &&
           eglParams.renderer != EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE))
      {
          glClear(GL_COLOR_BUFFER_BIT);
      }
  
      const auto &params = GetParam();
  
      for (unsigned int it = 0; it < params.iterations; it++)
      {
          if (params.indexBufferChanged)
          {
              glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(params.type) * mIndexData.size(),
                              mIndexData.data());
          }
          glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(mCount), params.type, 0);
      }
  
      ASSERT_GL_NO_ERROR();
  }
  
  DrawElementsPerfParams DrawElementsPerfD3D11Params(bool indexBufferChanged)
  {
      DrawElementsPerfParams params;
      params.eglParameters      = angle::egl_platform::D3D11();
      params.indexBufferChanged = indexBufferChanged;
      return params;
  }
  
  DrawElementsPerfParams DrawElementsPerfD3D9Params(bool indexBufferChanged)
  {
      DrawElementsPerfParams params;
      params.eglParameters      = angle::egl_platform::D3D9();
      params.indexBufferChanged = indexBufferChanged;
      return params;
  }
  
  DrawElementsPerfParams DrawElementsPerfOpenGLParams(bool indexBufferChanged)
  {
      DrawElementsPerfParams params;
      params.eglParameters      = angle::egl_platform::OPENGL();
      params.indexBufferChanged = indexBufferChanged;
      return params;
  }
  
  TEST_P(DrawElementsPerfBenchmark, Run)
  {
      run();
  }
  
  ANGLE_INSTANTIATE_TEST(DrawElementsPerfBenchmark,
                         DrawElementsPerfD3D9Params(false),
                         DrawElementsPerfD3D9Params(true),
                         DrawElementsPerfD3D11Params(false),
                         DrawElementsPerfD3D11Params(true),
                         DrawElementsPerfOpenGLParams(false),
                         DrawElementsPerfOpenGLParams(true));
  
  }  // namespace
  

Download