kc3-lang/angle/src/tests/test_utils/draw_call_perf_utils.cpp

• Show log

  Commit

• Hash : c78ebccd
  Author :
  Date : 2021-09-09T16:47:26
  

  Perf: Add _many_tex_draw test
  
  Add a new perf test _many_tex_draw, which draws with 8 textures bound.
  
  The intent of this test is to stress calls like retain() with various
  implementations of vk::Resource.
  
  Additionally, this CL updates the textures to use format GL_RGBA, rather
  than GL_RGB, to avoid the emulation step that's required due to the lack
  of support for the 3 channel format.
  
  Bug: angleproject:5971
  Test: DrawCallPerfBenchmark.Run/*_many_tex_draw
  Change-Id: Iffb39b76fab68cc2a76dfd2da38db7e77cb4dac0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3152171
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Charlie Lao <cclao@google.com>
  Commit-Queue: Tim Van Patten <timvp@google.com>
  

Download

• src/tests/test_utils/draw_call_perf_utils.cpp

• //
  // Copyright 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.
  //
  // draw_call_perf_utils.cpp:
  //   Common utilities for performance tests that need to do a large amount of draw calls.
  //
  
  #include "draw_call_perf_utils.h"
  
  #include <vector>
  
  #include "util/shader_utils.h"
  
  namespace
  {
  constexpr char kSimpleScaleAndOffsetVS[] = R"(attribute vec2 vPosition;
  uniform float uScale;
  uniform float uOffset;
  void main()
  {
      gl_Position = vec4(vPosition * vec2(uScale) + vec2(uOffset), 0, 1);
  })";
  
  constexpr char kSimpleDrawVS[] = R"(attribute vec2 vPosition;
  const float scale = 0.5;
  const float offset = -0.5;
  
  void main()
  {
      gl_Position = vec4(vPosition * vec2(scale) + vec2(offset), 0, 1);
  })";
  
  constexpr char kSimpleTexCoordVS[] = R"(attribute vec2 vPosition;
  varying vec2 texCoord;
  void main()
  {
      gl_Position = vec4(vPosition, 0, 1);
      texCoord = vPosition * 0.5 + vec2(0.5);
  })";
  
  constexpr char kSimpleFS[] = R"(precision mediump float;
  void main()
  {
      gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
  })";
  
  constexpr char kSimpleTextureFS[] = R"(precision mediump float;
  varying vec2 texCoord;
  uniform sampler2D tex;
  void main()
  {
      gl_FragColor = texture2D(tex, texCoord);
  })";
  
  constexpr char kDoubleTextureFS[] = R"(precision mediump float;
  varying vec2 texCoord;
  uniform sampler2D tex1;
  uniform sampler2D tex2;
  void main()
  {
      gl_FragColor = texture2D(tex1, texCoord) + texture2D(tex2, texCoord);
  })";
  
  constexpr char kEightTextureFS[] = R"(precision mediump float;
  varying vec2 texCoord;
  uniform sampler2D tex1;
  uniform sampler2D tex2;
  uniform sampler2D tex3;
  uniform sampler2D tex4;
  uniform sampler2D tex5;
  uniform sampler2D tex6;
  uniform sampler2D tex7;
  uniform sampler2D tex8;
  void main()
  {
      gl_FragColor = texture2D(tex1, texCoord) + texture2D(tex2, texCoord) +
                     texture2D(tex3, texCoord) + texture2D(tex4, texCoord) +
                     texture2D(tex5, texCoord) + texture2D(tex6, texCoord) +
                     texture2D(tex7, texCoord) + texture2D(tex8, texCoord);
  })";
  
  void Generate2DTriangleData(size_t numTris, std::vector<float> *floatData)
  {
      for (size_t triIndex = 0; triIndex < numTris; ++triIndex)
      {
          floatData->push_back(1.0f);
          floatData->push_back(2.0f);
  
          floatData->push_back(0.0f);
          floatData->push_back(0.0f);
  
          floatData->push_back(2.0f);
          floatData->push_back(0.0f);
      }
  }
  
  }  // anonymous namespace
  
  GLuint SetupSimpleScaleAndOffsetProgram()
  {
      GLuint program = CompileProgram(kSimpleScaleAndOffsetVS, kSimpleFS);
      if (program == 0u)
      {
          return program;
      }
  
      // Use the program object
      glUseProgram(program);
  
      GLfloat scale  = 0.5f;
      GLfloat offset = -0.5f;
  
      glUniform1f(glGetUniformLocation(program, "uScale"), scale);
      glUniform1f(glGetUniformLocation(program, "uOffset"), offset);
      return program;
  }
  
  GLuint SetupSimpleDrawProgram()
  {
      GLuint program = CompileProgram(kSimpleDrawVS, kSimpleFS);
      if (program == 0u)
      {
          return program;
      }
  
      // Use the program object
      glUseProgram(program);
  
      return program;
  }
  
  GLuint SetupSimpleTextureProgram()
  {
      GLuint program = CompileProgram(kSimpleTexCoordVS, kSimpleTextureFS);
      if (program == 0u)
      {
          return program;
      }
  
      // Use the program object
      glUseProgram(program);
  
      return program;
  }
  
  GLuint SetupDoubleTextureProgram()
  {
      GLuint program = CompileProgram(kSimpleTexCoordVS, kDoubleTextureFS);
      if (program == 0u)
      {
          return program;
      }
  
      // Use the program object
      glUseProgram(program);
  
      return program;
  }
  
  GLuint SetupEightTextureProgram()
  {
      GLuint program = CompileProgram(kSimpleTexCoordVS, kEightTextureFS);
      if (program == 0u)
      {
          return program;
      }
  
      // Use the program object
      glUseProgram(program);
  
      return program;
  }
  
  GLuint Create2DTriangleBuffer(size_t numTris, GLenum usage)
  {
      GLuint buffer = 0u;
      glGenBuffers(1, &buffer);
      glBindBuffer(GL_ARRAY_BUFFER, buffer);
  
      std::vector<GLfloat> floatData;
      Generate2DTriangleData(numTris, &floatData);
  
      // To avoid generating GL errors when testing validation-only with zero triangles.
      if (floatData.empty())
      {
          floatData.push_back(0.0f);
      }
  
      glBufferData(GL_ARRAY_BUFFER, floatData.size() * sizeof(GLfloat), &floatData[0], usage);
  
      return buffer;
  }
  
  void CreateColorFBO(GLsizei width, GLsizei height, GLuint *fbo, GLuint *texture)
  {
      glGenFramebuffers(1, fbo);
      glBindFramebuffer(GL_FRAMEBUFFER, *fbo);
      glGenTextures(1, texture);
      glBindTexture(GL_TEXTURE_2D, *texture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *texture, 0);
  }
  

Download