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

• Show log

  Commit

• Hash : 82ff27bf
  Author :
  Date : 2022-07-08T12:38:41
  

  Add Metal to the perf tests
  
  Bug: angleproject:7296
  Change-Id: I69cd17c464d48b933c51466bf9d21c278438c4e1
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3753277
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/tests/perf_tests/TexturesPerf.cpp

• //
  // Copyright 2016 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.
  //
  // TexturesPerf:
  //   Performance test for setting texture state.
  //
  
  #include "ANGLEPerfTest.h"
  
  #include <iostream>
  #include <random>
  #include <sstream>
  
  #include "common/debug.h"
  #include "util/shader_utils.h"
  
  namespace angle
  {
  constexpr unsigned int kIterationsPerStep = 256;
  
  enum class Frequency
  {
      Always,
      Sometimes,
      Never
  };
  
  size_t GetFrequencyValue(Frequency frequency, size_t sometimesValue)
  {
      switch (frequency)
      {
          case Frequency::Always:
              return 1;
          case Frequency::Never:
              return std::numeric_limits<size_t>::max();
          case Frequency::Sometimes:
              return sometimesValue;
          default:
              UNREACHABLE();
              return 0;
      }
  }
  
  std::string FrequencyToString(Frequency frequency)
  {
      switch (frequency)
      {
          case Frequency::Always:
              return "always";
          case Frequency::Sometimes:
              return "sometimes";
          case Frequency::Never:
              return "never";
          default:
              UNREACHABLE();
              return "";
      }
  }
  
  constexpr size_t kRebindSometimesFrequency      = 5;
  constexpr size_t kStateUpdateSometimesFrequency = 3;
  
  struct TexturesParams final : public RenderTestParams
  {
      TexturesParams()
      {
          iterationsPerStep = kIterationsPerStep;
  
          // Common default params
          majorVersion = 2;
          minorVersion = 0;
          windowWidth  = 720;
          windowHeight = 720;
  
          numTextures                 = 8;
          textureRebindFrequency      = Frequency::Sometimes;
          textureStateUpdateFrequency = Frequency::Sometimes;
          textureMipCount             = 8;
  
          webgl = false;
      }
  
      std::string story() const override;
      size_t numTextures;
      Frequency textureRebindFrequency;
      Frequency textureStateUpdateFrequency;
      size_t textureMipCount;
  
      bool webgl;
  };
  
  std::ostream &operator<<(std::ostream &os, const TexturesParams &params)
  {
      os << params.backendAndStory().substr(1);
      return os;
  }
  
  std::string TexturesParams::story() const
  {
      std::stringstream strstr;
  
      strstr << RenderTestParams::story();
      strstr << "_" << FrequencyToString(textureRebindFrequency) << "_rebind";
      strstr << "_" << FrequencyToString(textureStateUpdateFrequency) << "_update";
  
      if (webgl)
      {
          strstr << "_webgl";
      }
  
      return strstr.str();
  }
  
  class TexturesBenchmark : public ANGLERenderTest,
                            public ::testing::WithParamInterface<TexturesParams>
  {
    public:
      TexturesBenchmark();
  
      void initializeBenchmark() override;
      void destroyBenchmark() override;
      void drawBenchmark() override;
  
    private:
      void initShaders();
      void initTextures();
  
      std::vector<GLuint> mTextures;
  
      GLuint mProgram;
      std::vector<GLuint> mUniformLocations;
  };
  
  TexturesBenchmark::TexturesBenchmark() : ANGLERenderTest("Textures", GetParam()), mProgram(0u)
  {
      setWebGLCompatibilityEnabled(GetParam().webgl);
      setRobustResourceInit(GetParam().webgl);
  }
  
  void TexturesBenchmark::initializeBenchmark()
  {
      const auto &params = GetParam();
  
      // Verify the uniform counts are within the limits
      GLint maxTextureUnits;
      glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
      if (params.numTextures > static_cast<size_t>(maxTextureUnits))
      {
          FAIL() << "Texture count (" << params.numTextures << ")"
                 << " exceeds maximum texture unit count: " << maxTextureUnits << std::endl;
      }
  
      initShaders();
      initTextures();
      glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
      glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
  
      ASSERT_GL_NO_ERROR();
  }
  
  std::string GetUniformLocationName(size_t idx, bool vertexShader)
  {
      std::stringstream strstr;
      strstr << (vertexShader ? "vs" : "fs") << "_u_" << idx;
      return strstr.str();
  }
  
  void TexturesBenchmark::initShaders()
  {
      const auto &params = GetParam();
  
      std::string vs =
          "void main()\n"
          "{\n"
          "    gl_Position = vec4(0, 0, 0, 0);\n"
          "}\n";
  
      std::stringstream fstrstr;
      for (size_t i = 0; i < params.numTextures; i++)
      {
          fstrstr << "uniform sampler2D tex" << i << ";";
      }
      fstrstr << "void main()\n"
                 "{\n"
                 "    gl_FragColor = vec4(0, 0, 0, 0)";
      for (size_t i = 0; i < params.numTextures; i++)
      {
          fstrstr << "+ texture2D(tex" << i << ", vec2(0, 0))";
      }
      fstrstr << ";\n"
                 "}\n";
  
      mProgram = CompileProgram(vs.c_str(), fstrstr.str().c_str());
      ASSERT_NE(0u, mProgram);
  
      for (size_t i = 0; i < params.numTextures; ++i)
      {
          std::stringstream uniformName;
          uniformName << "tex" << i;
  
          GLint location = glGetUniformLocation(mProgram, uniformName.str().c_str());
          ASSERT_NE(-1, location);
          mUniformLocations.push_back(location);
      }
  
      // Use the program object
      glUseProgram(mProgram);
  }
  
  void TexturesBenchmark::initTextures()
  {
      const auto &params = GetParam();
  
      size_t textureSize = static_cast<size_t>(1) << params.textureMipCount;
      std::vector<GLubyte> textureData(textureSize * textureSize * 4);
      for (auto &byte : textureData)
      {
          byte = rand() % 255u;
      }
  
      for (size_t texIndex = 0; texIndex < params.numTextures; texIndex++)
      {
          GLuint tex = 0;
          glGenTextures(1, &tex);
  
          glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + texIndex));
          glBindTexture(GL_TEXTURE_2D, tex);
          for (size_t mip = 0; mip < params.textureMipCount; mip++)
          {
              GLsizei levelSize = static_cast<GLsizei>(textureSize >> mip);
              glTexImage2D(GL_TEXTURE_2D, static_cast<GLint>(mip), GL_RGBA, levelSize, levelSize, 0,
                           GL_RGBA, GL_UNSIGNED_BYTE, textureData.data());
          }
          mTextures.push_back(tex);
  
          glUniform1i(mUniformLocations[texIndex], static_cast<GLint>(texIndex));
      }
  }
  
  void TexturesBenchmark::destroyBenchmark()
  {
      glDeleteProgram(mProgram);
  }
  
  void TexturesBenchmark::drawBenchmark()
  {
      const auto &params = GetParam();
  
      size_t textureRebindPeriod =
          GetFrequencyValue(params.textureRebindFrequency, kRebindSometimesFrequency);
      size_t textureStateUpdatePeriod =
          GetFrequencyValue(params.textureStateUpdateFrequency, kStateUpdateSometimesFrequency);
  
      for (size_t it = 0; it < params.iterationsPerStep; ++it)
      {
          if (it % textureRebindPeriod == 0)
          {
              // Swap two textures
              size_t swapTexture = (it / textureRebindPeriod) % (params.numTextures - 1);
  
              glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + swapTexture));
              glBindTexture(GL_TEXTURE_2D, mTextures[swapTexture]);
              glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + swapTexture + 1));
              glBindTexture(GL_TEXTURE_2D, mTextures[swapTexture + 1]);
              std::swap(mTextures[swapTexture], mTextures[swapTexture + 1]);
          }
  
          if (it % textureStateUpdatePeriod == 0)
          {
              // Update a texture's state
              size_t stateUpdateCount = it / textureStateUpdatePeriod;
  
              const size_t numUpdateTextures = 4;
              ASSERT_LE(numUpdateTextures, params.numTextures);
  
              size_t firstTexture = stateUpdateCount % (params.numTextures - numUpdateTextures);
  
              for (size_t updateTextureIdx = 0; updateTextureIdx < numUpdateTextures;
                   updateTextureIdx++)
              {
                  size_t updateTexture = firstTexture + updateTextureIdx;
                  glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + updateTexture));
  
                  const GLenum minFilters[] = {
                      GL_NEAREST,
                      GL_LINEAR,
                      GL_NEAREST_MIPMAP_NEAREST,
                      GL_LINEAR_MIPMAP_NEAREST,
                      GL_NEAREST_MIPMAP_LINEAR,
                      GL_LINEAR_MIPMAP_LINEAR,
                  };
                  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                                  minFilters[stateUpdateCount % ArraySize(minFilters)]);
  
                  const GLenum magFilters[] = {
                      GL_NEAREST,
                      GL_LINEAR,
                  };
                  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                                  magFilters[stateUpdateCount % ArraySize(magFilters)]);
  
                  const GLenum wrapParameters[] = {
                      GL_CLAMP_TO_EDGE,
                      GL_REPEAT,
                      GL_MIRRORED_REPEAT,
                  };
                  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                                  wrapParameters[stateUpdateCount % ArraySize(wrapParameters)]);
                  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                                  wrapParameters[stateUpdateCount % ArraySize(wrapParameters)]);
              }
          }
  
          glDrawArrays(GL_TRIANGLES, 0, 3);
      }
  
      ASSERT_GL_NO_ERROR();
  }
  
  TexturesParams ApplyFrequencies(const TexturesParams &paramsIn,
                                  Frequency rebindFrequency,
                                  Frequency stateUpdateFrequency)
  {
      TexturesParams paramsOut              = paramsIn;
      paramsOut.textureRebindFrequency      = rebindFrequency;
      paramsOut.textureStateUpdateFrequency = stateUpdateFrequency;
      return paramsOut;
  }
  
  TexturesParams D3D11Params(bool webglCompat,
                             Frequency rebindFrequency,
                             Frequency stateUpdateFrequency)
  {
      TexturesParams params;
      params.eglParameters = egl_platform::D3D11_NULL();
      params.webgl         = webglCompat;
      return ApplyFrequencies(params, rebindFrequency, stateUpdateFrequency);
  }
  
  TexturesParams MetalParams(bool webglCompat,
                             Frequency rebindFrequency,
                             Frequency stateUpdateFrequency)
  {
      TexturesParams params;
      params.eglParameters = egl_platform::METAL();
      params.webgl         = webglCompat;
      return ApplyFrequencies(params, rebindFrequency, stateUpdateFrequency);
  }
  
  TexturesParams OpenGLOrGLESParams(bool webglCompat,
                                    Frequency rebindFrequency,
                                    Frequency stateUpdateFrequency)
  {
      TexturesParams params;
      params.eglParameters = egl_platform::OPENGL_OR_GLES_NULL();
      params.webgl         = webglCompat;
      return ApplyFrequencies(params, rebindFrequency, stateUpdateFrequency);
  }
  
  TexturesParams VulkanParams(bool webglCompat,
                              Frequency rebindFrequency,
                              Frequency stateUpdateFrequency)
  {
      TexturesParams params;
      params.eglParameters = egl_platform::VULKAN_NULL();
      params.webgl         = webglCompat;
      return ApplyFrequencies(params, rebindFrequency, stateUpdateFrequency);
  }
  
  TEST_P(TexturesBenchmark, Run)
  {
      run();
  }
  
  ANGLE_INSTANTIATE_TEST(TexturesBenchmark,
                         D3D11Params(false, Frequency::Sometimes, Frequency::Sometimes),
                         D3D11Params(true, Frequency::Sometimes, Frequency::Sometimes),
                         D3D11Params(false, Frequency::Always, Frequency::Always),
                         D3D11Params(true, Frequency::Always, Frequency::Always),
                         MetalParams(false, Frequency::Sometimes, Frequency::Sometimes),
                         MetalParams(true, Frequency::Sometimes, Frequency::Sometimes),
                         MetalParams(false, Frequency::Always, Frequency::Always),
                         MetalParams(true, Frequency::Always, Frequency::Always),
                         OpenGLOrGLESParams(false, Frequency::Sometimes, Frequency::Sometimes),
                         OpenGLOrGLESParams(true, Frequency::Sometimes, Frequency::Sometimes),
                         OpenGLOrGLESParams(false, Frequency::Always, Frequency::Always),
                         OpenGLOrGLESParams(true, Frequency::Always, Frequency::Always),
                         VulkanParams(false, Frequency::Sometimes, Frequency::Sometimes),
                         VulkanParams(true, Frequency::Sometimes, Frequency::Sometimes),
                         VulkanParams(false, Frequency::Always, Frequency::Always),
                         VulkanParams(true, Frequency::Always, Frequency::Always),
                         VulkanParams(false, Frequency::Always, Frequency::Never));
  }  // namespace angle
  

Download