kc3-lang/angle/tests/perf_tests/SimpleBenchmarks.cpp

• Show log

  Commit

• Hash : fc63152a
  Author :
  Date : 2014-10-09T12:55:28
  

  Use Chromium perf bot output style for perf test.
  
  The Chromium style output will allow the perf bots to collect data
  from our performance tests.
  
  BUG=angle:744
  
  Change-Id: I2ffdace688004edf2918ead2a3e2aa2a6c4daf95
  Reviewed-on: https://chromium-review.googlesource.com/220361
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• tests/perf_tests/SimpleBenchmarks.cpp

• //
  // 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.
  //
  
  #include "SimpleBenchmark.h"
  #include "BufferSubData.h"
  #include "TexSubImage.h"
  #include "PointSprites.h"
  
  EGLint platforms[] =
  {
      EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE,
      EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE
  };
  
  GLenum vertexTypes[] = { GL_FLOAT };
  GLint componentCounts[] = { 4 };
  GLboolean vertexNorms[] = { GL_FALSE };
  GLsizeiptr updateSizes[] = { 300 };
  GLsizeiptr bufferSizes[] = { 1024 * 1024 };
  unsigned int iterationCounts[] = { 10 };
  unsigned int updatesEveryNFrames[] = { 1, 4 };
  
  int main(int argc, char **argv)
  {
      std::vector<BufferSubDataParams> subDataParams;
  
      for (size_t platIt = 0; platIt < ArraySize(platforms); platIt++)
      {
          for (size_t typeIt = 0; typeIt < ArraySize(vertexTypes); typeIt++)
          {
              for (size_t compIt = 0; compIt < ArraySize(componentCounts); compIt++)
              {
                  for (size_t normIt = 0; normIt < ArraySize(vertexNorms); normIt++)
                  {
                      // No normalized float data
                      if (vertexTypes[typeIt] == GL_FLOAT && vertexNorms[normIt] == GL_TRUE)
                      {
                          continue;
                      }
  
                      for (size_t updateIt = 0; updateIt < ArraySize(updateSizes); updateIt++)
                      {
                          for (size_t bufszIt = 0; bufszIt < ArraySize(bufferSizes); bufszIt++)
                          {
                              for (size_t itIt = 0; itIt < ArraySize(iterationCounts); itIt++)
                              {
                                  for (size_t nfrIt = 0; nfrIt < ArraySize(updatesEveryNFrames); nfrIt++)
                                  {
                                      BufferSubDataParams params;
                                      params.requestedRenderer = platforms[platIt];
                                      params.vertexType = vertexTypes[typeIt];
                                      params.vertexComponentCount = componentCounts[compIt];
                                      params.vertexNormalized = vertexNorms[normIt];
                                      params.updateSize = updateSizes[updateIt];
                                      params.bufferSize = bufferSizes[bufszIt];
                                      params.iterations = iterationCounts[itIt];
                                      params.updatesEveryNFrames = updatesEveryNFrames[nfrIt];
  
                                      if (updateSizes[updateIt] == 0)
                                      {
                                          if (nfrIt > 0)
                                          {
                                              continue;
                                          }
                                          else
                                          {
                                              params.updatesEveryNFrames = 1;
                                          }
                                      }
  
                                      subDataParams.push_back(params);
                                  }
                              }
                          }
                      }
                  }
              }
          }
      }
  
      // Enumerates permutations
      RunBenchmarks<BufferSubDataBenchmark>(subDataParams);
  
      std::vector<TexSubImageParams> subImageParams;
  
      for (size_t platIt = 0; platIt < ArraySize(platforms); platIt++)
      {
          TexSubImageParams params;
  
          params.requestedRenderer = platforms[platIt];
          params.imageWidth = 1024;
          params.imageHeight = 1024;
          params.subImageHeight = 64;
          params.subImageWidth = 64;
          params.iterations = 10;
  
          subImageParams.push_back(params);
      }
  
      RunBenchmarks<TexSubImageBenchmark>(subImageParams);
  
      std::vector<PointSpritesParams> pointSpriteParams;
  
      for (size_t platIt = 0; platIt < ArraySize(platforms); platIt++)
      {
          PointSpritesParams params;
  
          params.requestedRenderer = platforms[platIt];
          params.iterations = 10;
          params.count = 10;
          params.size = 3.0f;
          params.numVaryings = 3;
  
          pointSpriteParams.push_back(params);
      }
  
      RunBenchmarks<PointSpritesBenchmark>(pointSpriteParams);
  }
  

Download