Use JSON as startup parameters to BufferSubData test.

tests/perf_tests/BufferSubData.cpp

@@ -130,6 +130,8 @@ std::string BufferSubDataParams::suffix() const
 {
     std::stringstream strstr;
 
+    strstr << BenchmarkParams::suffix();
+
     if (vertexNormalized)
     {
         strstr << "_norm";
@@ -148,7 +150,7 @@ std::string BufferSubDataParams::suffix() const
     }
 
     strstr << vertexComponentCount;
-    strstr << "_every" << updatesEveryNFrames;
+    strstr << "_every" << updateRate;
 
     return strstr.str();
 }
@@ -281,7 +283,7 @@ void BufferSubDataBenchmark::drawBenchmark()
 {
     for (unsigned int it = 0; it < mParams.iterations; it++)
     {
-        if (mParams.updateSize > 0 && ((mNumFrames % mParams.updatesEveryNFrames) == 0))
+        if (mParams.updateSize > 0 && ((mNumFrames % mParams.updateRate) == 0))
         {
             glBufferSubData(GL_ARRAY_BUFFER, 0, mParams.updateSize, mUpdateData);
         }

tests/perf_tests/BufferSubData.h

@@ -13,7 +13,7 @@ struct BufferSubDataParams : public BenchmarkParams
     GLboolean vertexNormalized;
     GLenum vertexType;
     GLint vertexComponentCount;
-    unsigned int updatesEveryNFrames;
+    unsigned int updateRate;
 
     // static parameters
     GLsizeiptr updateSize;
@@ -31,6 +31,8 @@ class BufferSubDataBenchmark : public SimpleBenchmark
     virtual void beginDrawBenchmark();
     virtual void drawBenchmark();
 
+    typedef BufferSubDataParams Params;
+
   private:
     DISALLOW_COPY_AND_ASSIGN(BufferSubDataBenchmark);
 

tests/perf_tests/PointSprites.cpp

@@ -17,7 +17,8 @@ std::string PointSpritesParams::suffix() const
 {
     std::stringstream strstr;
 
-    strstr << "_" << count << "_" << size << "px"
+    strstr << BenchmarkParams::suffix()
+           << "_" << count << "_" << size << "px"
            << "_" << numVaryings << "vars";
 
     return strstr.str();

tests/perf_tests/PointSprites.h

@@ -28,6 +28,8 @@ public:
     virtual void beginDrawBenchmark();
     virtual void drawBenchmark();
 
+    typedef PointSpritesParams Params;
+
 private:
     DISALLOW_COPY_AND_ASSIGN(PointSpritesBenchmark);
 

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);
-}

tests/perf_tests/TexSubImage.cpp

@@ -13,7 +13,8 @@
 
 std::string TexSubImageParams::suffix() const
 {
-    return "";
+    // TODO(jmadill)
+    return BenchmarkParams::suffix();
 }
 
 TexSubImageBenchmark::TexSubImageBenchmark(const TexSubImageParams &params)

tests/perf_tests/TexSubImage.h

@@ -28,6 +28,8 @@ class TexSubImageBenchmark : public SimpleBenchmark
     virtual void beginDrawBenchmark();
     virtual void drawBenchmark();
 
+    typedef TexSubImageParams Params;
+
   private:
     GLuint createTexture();
 

tests/perf_tests/angle_perf_test_main.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"
+
+#include <iostream>
+#include <rapidjson/document.h>
+#include <rapidjson/filestream.h>
+
+namespace
+{
+
+template <class T>
+struct Optional
+{
+    Optional()
+        : valid(false),
+          value(T())
+    {}
+
+    explicit Optional(T valueIn)
+        : valid(true),
+          value(valueIn)
+    {}
+
+    Optional(const Optional &other)
+        : valid(other.valid),
+          value(other.value)
+    {}
+
+    Optional &operator=(const Optional &other)
+    {
+        this.valid = other.valid;
+        this.value = otehr.value;
+        return *this;
+    }
+
+    static Optional None()
+    {
+        return Optional();
+    }
+
+    bool valid;
+    T value;
+};
+
+Optional<std::string> GetStringMember(const rapidjson::Document &document, const char *name)
+{
+    auto typeIt = document.FindMember(name);
+    if (typeIt == document.MemberEnd() || !typeIt->value.IsString())
+    {
+        std::cerr << "JSON has missing or bad string member '" << name << "'" << std::endl;
+        return Optional<std::string>::None();
+    }
+
+    return Optional<std::string>(typeIt->value.GetString());
+}
+
+Optional<bool> GetBoolMember(const rapidjson::Document &document, const char *name)
+{
+    auto typeIt = document.FindMember(name);
+    if (typeIt == document.MemberEnd() || !typeIt->value.IsBool())
+    {
+        std::cerr << "JSON has missing or bad bool member '" << name << "'" << std::endl;
+        return Optional<bool>::None();
+    }
+
+    return Optional<bool>(typeIt->value.GetBool());
+}
+
+Optional<int> GetIntMember(const rapidjson::Document &document, const char *name)
+{
+    auto typeIt = document.FindMember(name);
+    if (typeIt == document.MemberEnd() || !typeIt->value.IsInt())
+    {
+        std::cerr << "JSON has missing or bad int member '" << name << "'" << std::endl;
+        return Optional<int>::None();
+    }
+
+    return Optional<int>(typeIt->value.GetInt());
+}
+
+Optional<unsigned int> GetUintMember(const rapidjson::Document &document, const char *name)
+{
+    auto typeIt = document.FindMember(name);
+    if (typeIt == document.MemberEnd() || !typeIt->value.IsUint())
+    {
+        std::cerr << "JSON has missing or bad uint member '" << name << "'" << std::endl;
+        return Optional<unsigned int>::None();
+    }
+
+    return Optional<unsigned int>(typeIt->value.GetUint());
+}
+
+EGLint ParseRendererType(const std::string &value)
+{
+    if (value == "d3d11")
+    {
+        return EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
+    }
+    else if (value == "d3d9")
+    {
+        return EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
+    }
+    else if (value == "warp")
+    {
+        // TODO(jmadill): other attributes for warp
+        return EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
+    }
+    else if (value == "default")
+    {
+        return EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+    }
+    else
+    {
+        return EGL_NONE;
+    }
+}
+
+GLenum ParseAttribType(const std::string &value)
+{
+    if (value == "float")
+    {
+        return GL_FLOAT;
+    }
+    else if (value == "int")
+    {
+        return GL_INT;
+    }
+    else if (value == "uint")
+    {
+        return GL_UNSIGNED_INT;
+    }
+    else if (value == "short")
+    {
+        return GL_SHORT;
+    }
+    else if (value == "ushort")
+    {
+        return GL_UNSIGNED_SHORT;
+    }
+    else if (value == "byte")
+    {
+        return GL_BYTE;
+    }
+    else if (value == "ubyte")
+    {
+        return GL_UNSIGNED_BYTE;
+    }
+    else
+    {
+        return GL_NONE;
+    }
+}
+
+bool ParseBenchmarkParams(const rapidjson::Document &document, BufferSubDataParams *params)
+{
+    // Validate params
+    auto type = GetStringMember(document, "type");
+    auto components = GetUintMember(document, "components");
+    auto normalized = GetBoolMember(document, "normalized");
+    auto updateSize = GetUintMember(document, "update_size");
+    auto bufferSize = GetUintMember(document, "buffer_size");
+    auto iterations = GetUintMember(document, "iterations");
+    auto updateRate = GetUintMember(document, "update_rate");
+
+    if (!type.valid || !components.valid || !normalized.valid || !updateSize.valid ||
+        !bufferSize.valid || !iterations.valid || !updateRate.valid)
+    {
+        return false;
+    }
+
+    GLenum vertexType = ParseAttribType(type.value);
+    if (vertexType == GL_NONE)
+    {
+        std::cerr << "Invalid attribute type: " << type.value << std::endl;
+        return false;
+    }
+
+    if (components.value < 1 || components.value > 4)
+    {
+        std::cerr << "Invalid component count: " << components.value << std::endl;
+        return false;
+    }
+
+    if (normalized.value && vertexType == GL_FLOAT)
+    {
+        std::cerr << "Normalized float is not a valid vertex type." << std::endl;
+        return false;
+    }
+
+    if (bufferSize.value == 0)
+    {
+        std::cerr << "Zero buffer size is not valid." << std::endl;
+        return false;
+    }
+
+    if (iterations.value == 0)
+    {
+        std::cerr << "Zero iterations not valid." << std::endl;
+        return false;
+    }
+
+    params->vertexType = vertexType;
+    params->vertexComponentCount = components.value;
+    params->vertexNormalized = normalized.value;
+    params->updateSize = updateSize.value;
+    params->bufferSize = bufferSize.value;
+    params->iterations = iterations.value;
+    params->updateRate = updateRate.value;
+
+    return true;
+}
+
+bool ParseBenchmarkParams(const rapidjson::Document &document, TexSubImageParams *params)
+{
+    // TODO(jmadill): Parse and validate parameters
+
+    params->imageWidth = 1024;
+    params->imageHeight = 1024;
+    params->subImageHeight = 64;
+    params->subImageWidth = 64;
+    params->iterations = 10;
+
+    return true;
+}
+
+bool ParseBenchmarkParams(const rapidjson::Document &document, PointSpritesParams *params)
+{
+    // TODO(jmadill): Parse and validate parameters
+
+    params->iterations = 10;
+    params->count = 10;
+    params->size = 3.0f;
+    params->numVaryings = 3;
+
+    return true;
+}
+
+template <class BenchT>
+int ParseAndRunBenchmark(EGLint rendererType, const rapidjson::Document &document)
+{
+    BenchT::Params params;
+    if (!ParseBenchmarkParams(document, &params))
+    {
+        // Parse or validation error
+        return 1;
+    }
+
+    params.requestedRenderer = rendererType;
+
+    BenchT benchmark(params);
+
+    // Run the benchmark
+    return benchmark.run();
+}
+
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 3)
+    {
+        std::cerr << "Must specify a renderer and source json file." << std::endl;
+        return 1;
+    }
+
+    EGLint rendererType = ParseRendererType(std::string(argv[1]));
+    if (rendererType == EGL_NONE)
+    {
+        std::cerr << "Invalid renderer type: " << argv[1] << std::endl;
+        return 1;
+    }
+
+    FILE *fp = fopen(argv[2], "rt");
+    if (fp == NULL)
+    {
+        std::cerr << "Cannot open " << argv[2] << std::endl;
+        return 1;
+    }
+
+    rapidjson::FileStream fileStream(fp);
+    rapidjson::Document document;
+
+    if (document.ParseStream(fileStream).HasParseError())
+    {
+        std::cerr << "JSON Parse error code " << document.GetParseError() << "." << std::endl;
+        return 1;
+    }
+
+    fclose(fp);
+
+    auto testName = GetStringMember(document, "test");
+
+    if (!testName.valid)
+    {
+        return 1;
+    }
+
+    if (testName.value == "BufferSubData")
+    {
+        return ParseAndRunBenchmark<BufferSubDataBenchmark>(rendererType, document);
+    }
+    else if (testName.value == "TexSubImage")
+    {
+        return ParseAndRunBenchmark<TexSubImageBenchmark>(rendererType, document);
+    }
+    else if (testName.value == "PointSprites")
+    {
+        return ParseAndRunBenchmark<PointSpritesBenchmark>(rendererType, document);
+    }
+    else
+    {
+        std::cerr << "Unknown test: " << testName.value << std::endl;
+        return 1;
+    }
+}

tests/perf_tests/buffersubdata.json

+{
+  "test": "BufferSubData",
+  "type": "float",
+  "components": 4,
+  "normalized": false,
+  "update_size": 300,
+  "buffer_size": 1048576,
+  "iterations": 10,
+  "update_rate": 1
+}

tests/perf_tests/pointsprites.json

+{
+  "test": "PointSprites"
+}

tests/perf_tests/texsubimage.json

+{
+  "test": "TexSubImage"
+}

tests/tests.gyp

@@ -224,9 +224,9 @@
                         'perf_tests/PointSprites.h',
                         'perf_tests/SimpleBenchmark.cpp',
                         'perf_tests/SimpleBenchmark.h',
-                        'perf_tests/SimpleBenchmarks.cpp',
                         'perf_tests/TexSubImage.cpp',
                         'perf_tests/TexSubImage.h',
+                        'perf_tests/angle_perf_test_main.cpp',
                         'perf_tests/third_party/perf/perf_test.cc',
                         'perf_tests/third_party/perf/perf_test.h',
                         '<@(rapidjson_headers)',