Use both null and real renders for draw call perf.

src/libANGLE/renderer/gl/DisplayGL.cpp

@@ -10,6 +10,7 @@
 
 #include "libANGLE/AttributeMap.h"
 #include "libANGLE/Context.h"
+#include "libANGLE/Display.h"
 #include "libANGLE/Surface.h"
 #include "libANGLE/renderer/gl/RendererGL.h"
 #include "libANGLE/renderer/gl/SurfaceGL.h"
@@ -30,7 +31,7 @@ DisplayGL::~DisplayGL()
 
 egl::Error DisplayGL::initialize(egl::Display *display)
 {
-    mRenderer = new RendererGL(getFunctionsGL());
+    mRenderer = new RendererGL(getFunctionsGL(), display->getAttributeMap());
     return egl::Error(EGL_SUCCESS);
 }
 

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -8,7 +8,10 @@
 
 #include "libANGLE/renderer/gl/RendererGL.h"
 
+#include <EGL/eglext.h>
+
 #include "common/debug.h"
+#include "libANGLE/AttributeMap.h"
 #include "libANGLE/Data.h"
 #include "libANGLE/Surface.h"
 #include "libANGLE/renderer/gl/BufferGL.h"
@@ -75,10 +78,11 @@ static void INTERNAL_GL_APIENTRY LogGLDebugMessage(GLenum source, GLenum type, G
 namespace rx
 {
 
-RendererGL::RendererGL(const FunctionsGL *functions)
+RendererGL::RendererGL(const FunctionsGL *functions, const egl::AttributeMap &attribMap)
     : Renderer(),
       mFunctions(functions),
-      mStateManager(nullptr)
+      mStateManager(nullptr),
+      mSkipDrawCalls(false)
 {
     ASSERT(mFunctions);
     mStateManager = new StateManagerGL(mFunctions, getRendererCaps());
@@ -94,6 +98,12 @@ RendererGL::RendererGL(const FunctionsGL *functions)
         mFunctions->debugMessageCallback(&LogGLDebugMessage, nullptr);
     }
 #endif
+
+    EGLint deviceType = attribMap.get(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE, EGL_NONE);
+    if (deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE)
+    {
+        mSkipDrawCalls = true;
+    }
 }
 
 RendererGL::~RendererGL()
@@ -122,7 +132,10 @@ gl::Error RendererGL::drawArrays(const gl::Data &data, GLenum mode,
         return error;
     }
 
-    mFunctions->drawArrays(mode, first, count);
+    if (!mSkipDrawCalls)
+    {
+        mFunctions->drawArrays(mode, first, count);
+    }
 
     return gl::Error(GL_NO_ERROR);
 }
@@ -143,7 +156,10 @@ gl::Error RendererGL::drawElements(const gl::Data &data, GLenum mode, GLsizei co
         return error;
     }
 
-    mFunctions->drawElements(mode, count, type, drawIndexPointer);
+    if (!mSkipDrawCalls)
+    {
+        mFunctions->drawElements(mode, count, type, drawIndexPointer);
+    }
 
     return gl::Error(GL_NO_ERROR);
 }

src/libANGLE/renderer/gl/RendererGL.h

@@ -19,7 +19,7 @@ class StateManagerGL;
 class RendererGL : public Renderer
 {
   public:
-    RendererGL(const FunctionsGL *functions);
+    RendererGL(const FunctionsGL *functions, const egl::AttributeMap &attribMap);
     ~RendererGL() override;
 
     gl::Error flush() override;
@@ -76,6 +76,9 @@ class RendererGL : public Renderer
 
     const FunctionsGL *mFunctions;
     StateManagerGL *mStateManager;
+
+    // For performance debugging
+    bool mSkipDrawCalls;
 };
 
 }

src/libGLESv2/entry_points_egl_ext.cpp

@@ -220,7 +220,11 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
                   case EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE:
                   case EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE:
                   case EGL_PLATFORM_ANGLE_DEVICE_TYPE_REFERENCE_ANGLE:
+                    deviceTypeSpecified = true;
+                    break;
+
                   case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE:
+                    // This is a hidden option, accepted by the OpenGL back-end.
                     break;
 
                   default:
@@ -228,7 +232,6 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
                     return EGL_NO_DISPLAY;
                 }
                 deviceType = curAttrib[1];
-                deviceTypeSpecified = true;
                 break;
 
               default:

src/tests/perf_tests/BufferSubData.cpp

@@ -17,6 +17,18 @@ namespace
 
 struct BufferSubDataParams final : public RenderTestParams
 {
+    BufferSubDataParams()
+    {
+        // Common default values
+        glesMajorVersion = 2;
+        widowWidth = 512;
+        windowHeight = 512;
+        updateSize = 3000;
+        bufferSize = 40000000;
+        iterations = 2;
+        updateRate = 1;
+    }
+
     std::string suffix() const override;
 
     GLboolean vertexNormalized;
@@ -30,6 +42,12 @@ struct BufferSubDataParams final : public RenderTestParams
     unsigned int iterations;
 };
 
+inline std::ostream &operator<<(std::ostream &os, const BufferSubDataParams &params)
+{
+    os << params.suffix().substr(1);
+    return os;
+}
+
 class BufferSubDataBenchmark : public ANGLERenderTest,
                                public ::testing::WithParamInterface<BufferSubDataParams>
 {
@@ -318,54 +336,33 @@ void BufferSubDataBenchmark::drawBenchmark()
 BufferSubDataParams BufferUpdateD3D11Params()
 {
     BufferSubDataParams params;
-    params.glesMajorVersion = 2;
-    params.widowWidth = 512;
-    params.windowHeight = 512;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
     params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
     params.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;
-    params.updateSize = 3000;
-    params.bufferSize = 40000000;
-    params.iterations = 2;
-    params.updateRate = 1;
     return params;
 }
 
 BufferSubDataParams BufferUpdateD3D9Params()
 {
     BufferSubDataParams params;
-    params.glesMajorVersion = 2;
-    params.widowWidth = 512;
-    params.windowHeight = 512;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
     params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
     params.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;
-    params.updateSize = 3000;
-    params.bufferSize = 40000000;
-    params.iterations = 2;
-    params.updateRate = 1;
     return params;
 }
 
 BufferSubDataParams BufferUpdateOpenGLParams()
 {
     BufferSubDataParams params;
-    params.glesMajorVersion = 2;
-    params.widowWidth = 512;
-    params.windowHeight = 512;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    params.deviceType = EGL_DONT_CARE;
     params.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;
-    params.updateSize = 3000;
-    params.bufferSize = 40000000;
-    params.iterations = 2;
-    params.updateRate = 1;
     return params;
 }
 

src/tests/perf_tests/DrawCallPerf.cpp

@@ -15,8 +15,24 @@
 namespace
 {
 
+EGLint NullDeviceType(bool useNullDevice)
+{
+    return useNullDevice ? EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE : EGL_DONT_CARE;
+}
+
 struct DrawCallPerfParams final : public RenderTestParams
 {
+    // Common default options
+    DrawCallPerfParams()
+    {
+        glesMajorVersion = 2;
+        widowWidth = 256;
+        windowHeight = 256;
+        iterations = 50;
+        numTris = 1;
+        runTimeSeconds = 10.0;
+    }
+
     std::string suffix() const override
     {
         std::stringstream strstr;
@@ -28,6 +44,11 @@ struct DrawCallPerfParams final : public RenderTestParams
             strstr << "_validation_only";
         }
 
+        if (deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE)
+        {
+            strstr << "_null";
+        }
+
         return strstr.str();
     }
 
@@ -36,6 +57,12 @@ struct DrawCallPerfParams final : public RenderTestParams
     int numTris;
 };
 
+inline std::ostream &operator<<(std::ostream &os, const DrawCallPerfParams &params)
+{
+    os << params.suffix().substr(1);
+    return os;
+}
+
 class DrawCallPerfBenchmark : public ANGLERenderTest,
                               public ::testing::WithParamInterface<DrawCallPerfParams>
 {
@@ -159,61 +186,38 @@ void DrawCallPerfBenchmark::drawBenchmark()
     ASSERT_GL_NO_ERROR();
 }
 
-DrawCallPerfParams DrawCallPerfD3D11Params()
+DrawCallPerfParams DrawCallPerfD3D11Params(bool useNullDevice)
 {
     DrawCallPerfParams params;
-    params.glesMajorVersion = 2;
-    params.widowWidth = 256;
-    params.windowHeight = 256;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
-    params.iterations = 50;
-    params.numTris = 1;
-    params.runTimeSeconds = 10.0;
+    params.deviceType = NullDeviceType(useNullDevice);
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfValidationOnly()
+DrawCallPerfParams DrawCallPerfD3D9Params(bool useNullDevice)
 {
     DrawCallPerfParams params;
-    params.glesMajorVersion = 2;
-    params.widowWidth = 256;
-    params.windowHeight = 256;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
-    params.iterations = 100;
-    params.numTris = 0;
-    params.runTimeSeconds = 5.0;
+    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
+    params.deviceType = NullDeviceType(useNullDevice);
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfD3D9Params()
+DrawCallPerfParams DrawCallPerfOpenGLParams(bool useNullDevice)
 {
     DrawCallPerfParams params;
-    params.glesMajorVersion = 2;
-    params.widowWidth = 256;
-    params.windowHeight = 256;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
-    params.iterations = 50;
-    params.numTris = 1;
-    params.runTimeSeconds = 10.0;
+    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
+    params.deviceType = NullDeviceType(useNullDevice);
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfOpenGLParams()
+DrawCallPerfParams DrawCallPerfValidationOnly()
 {
     DrawCallPerfParams params;
-    params.glesMajorVersion = 2;
-    params.widowWidth = 256;
-    params.windowHeight = 256;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
-    // TODO(cwallez) we can't require a null device with OpenGL so
-    // the benchmark is unfair for OpenGL.
-    // params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
-    params.iterations = 50;
-    params.numTris = 1;
-    params.runTimeSeconds = 10.0;
+    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
+    params.iterations = 100;
+    params.numTris = 0;
+    params.runTimeSeconds = 5.0;
     return params;
 }
 
@@ -223,7 +227,12 @@ TEST_P(DrawCallPerfBenchmark, Run)
 }
 
 ANGLE_INSTANTIATE_TEST(DrawCallPerfBenchmark,
-                       DrawCallPerfD3D11Params(), DrawCallPerfD3D9Params(),
-                       DrawCallPerfOpenGLParams(), DrawCallPerfValidationOnly());
+                       DrawCallPerfD3D11Params(false),
+                       DrawCallPerfD3D9Params(false),
+                       DrawCallPerfOpenGLParams(false),
+                       DrawCallPerfD3D11Params(true),
+                       DrawCallPerfD3D9Params(true),
+                       DrawCallPerfOpenGLParams(true),
+                       DrawCallPerfValidationOnly());
 
 } // namespace

src/tests/perf_tests/PointSprites.cpp

@@ -19,6 +19,18 @@ namespace
 
 struct PointSpritesParams final : public RenderTestParams
 {
+    PointSpritesParams()
+    {
+        // Common default params
+        glesMajorVersion = 2;
+        widowWidth = 1280;
+        windowHeight = 720;
+        iterations = 10;
+        count = 10;
+        size = 3.0f;
+        numVaryings = 3;
+    }
+
     std::string suffix() const override;
 
     unsigned int count;
@@ -29,6 +41,12 @@ struct PointSpritesParams final : public RenderTestParams
     unsigned int iterations;
 };
 
+inline std::ostream &operator<<(std::ostream &os, const PointSpritesParams &params)
+{
+    os << params.suffix().substr(1);
+    return os;
+}
+
 class PointSpritesBenchmark : public ANGLERenderTest,
                               public ::testing::WithParamInterface<PointSpritesParams>
 {
@@ -184,54 +202,24 @@ void PointSpritesBenchmark::drawBenchmark()
 PointSpritesParams D3D11Params()
 {
     PointSpritesParams params;
-
-    params.glesMajorVersion = 2;
-    params.widowWidth = 1280;
-    params.windowHeight = 720;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
     params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
-
-    params.iterations = 10;
-    params.count = 10;
-    params.size = 3.0f;
-    params.numVaryings = 3;
-
     return params;
 }
 
 PointSpritesParams D3D9Params()
 {
     PointSpritesParams params;
-
-    params.glesMajorVersion = 2;
-    params.widowWidth = 1280;
-    params.windowHeight = 720;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
     params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
-
-    params.iterations = 10;
-    params.count = 10;
-    params.size = 3.0f;
-    params.numVaryings = 3;
-
     return params;
 }
 
 PointSpritesParams OpenGLParams()
 {
     PointSpritesParams params;
-
-    params.glesMajorVersion = 2;
-    params.widowWidth = 1280;
-    params.windowHeight = 720;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
-
-    params.iterations = 10;
-    params.count = 10;
-    params.size = 3.0f;
-    params.numVaryings = 3;
-
+    params.deviceType = EGL_DONT_CARE;
     return params;
 }
 

src/tests/perf_tests/TexSubImage.cpp

@@ -17,6 +17,20 @@ namespace
 
 struct TexSubImageParams final : public RenderTestParams
 {
+    TexSubImageParams()
+    {
+        // Common default parameters
+        glesMajorVersion = 2;
+        widowWidth = 512;
+        windowHeight = 512;
+
+        imageWidth = 1024;
+        imageHeight = 1024;
+        subImageWidth = 64;
+        subImageHeight = 64;
+        iterations = 3;
+    }
+
     std::string suffix() const override;
 
     // Static parameters
@@ -27,6 +41,12 @@ struct TexSubImageParams final : public RenderTestParams
     unsigned int iterations;
 };
 
+inline std::ostream &operator<<(std::ostream &os, const TexSubImageParams &params)
+{
+    os << params.suffix().substr(1);
+    return os;
+}
+
 class TexSubImageBenchmark : public ANGLERenderTest,
                              public ::testing::WithParamInterface<TexSubImageParams>
 {
@@ -251,57 +271,24 @@ void TexSubImageBenchmark::drawBenchmark()
 TexSubImageParams D3D11Params()
 {
     TexSubImageParams params;
-
-    params.glesMajorVersion = 2;
-    params.widowWidth = 512;
-    params.windowHeight = 512;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
     params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
-
-    params.imageWidth = 1024;
-    params.imageHeight = 1024;
-    params.subImageWidth = 64;
-    params.subImageHeight = 64;
-    params.iterations = 3;
-
     return params;
 }
 
 TexSubImageParams D3D9Params()
 {
     TexSubImageParams params;
-
-    params.glesMajorVersion = 2;
-    params.widowWidth = 512;
-    params.windowHeight = 512;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
     params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
-
-    params.imageWidth = 1024;
-    params.imageHeight = 1024;
-    params.subImageWidth = 64;
-    params.subImageHeight = 64;
-    params.iterations = 3;
-
     return params;
 }
 
 TexSubImageParams OpenGLParams()
 {
     TexSubImageParams params;
-
-    params.glesMajorVersion = 2;
-    params.widowWidth = 512;
-    params.windowHeight = 512;
     params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
-
-    params.imageWidth = 1024;
-    params.imageHeight = 1024;
-    params.subImageWidth = 64;
-    params.subImageHeight = 64;
-    params.iterations = 3;
-
+    params.deviceType = EGL_DONT_CARE;
     return params;
 }
 

util/EGLWindow.cpp

@@ -22,7 +22,7 @@ EGLPlatformParameters::EGLPlatformParameters()
     : renderer(EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE),
       majorVersion(EGL_DONT_CARE),
       minorVersion(EGL_DONT_CARE),
-      deviceType(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE)
+      deviceType(EGL_DONT_CARE)
 {
 }
 
@@ -30,8 +30,13 @@ EGLPlatformParameters::EGLPlatformParameters(EGLint renderer)
     : renderer(renderer),
       majorVersion(EGL_DONT_CARE),
       minorVersion(EGL_DONT_CARE),
-      deviceType(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE)
+      deviceType(EGL_DONT_CARE)
 {
+    if (renderer == EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE ||
+        renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+    {
+        deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    }
 }
 
 EGLPlatformParameters::EGLPlatformParameters(EGLint renderer, EGLint majorVersion, EGLint minorVersion, EGLint useWarp)
@@ -108,7 +113,7 @@ bool EGLWindow::initializeGL(OSWindow *osWindow)
     displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE);
     displayAttributes.push_back(mPlatform.minorVersion);
 
-    if (mPlatform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE || mPlatform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+    if (mPlatform.deviceType != EGL_DONT_CARE)
     {
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
         displayAttributes.push_back(mPlatform.deviceType);