Add a perf test for draw call overhead.

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -228,6 +228,8 @@ class Renderer9 : public RendererD3D
 
     RendererClass getRendererClass() const override { return RENDERER_D3D9; }
 
+    D3DDEVTYPE getD3D9DeviceType() const { return mDeviceType; }
+
   private:
     DISALLOW_COPY_AND_ASSIGN(Renderer9);
 

src/libANGLE/renderer/d3d/d3d9/SwapChain9.cpp

@@ -154,8 +154,10 @@ EGLint SwapChain9::reset(int backbufferWidth, int backbufferHeight, EGLint swapI
 
     const d3d9::TextureFormat &depthBufferd3dFormatInfo = d3d9::GetTextureFormatInfo(mDepthBufferFormat);
 
+    // Don't create a swapchain for NULLREF devices
+    D3DDEVTYPE deviceType = mRenderer->getD3D9DeviceType();
     EGLNativeWindowType window = mNativeWindow.getNativeWindow();
-    if (window)
+    if (window && deviceType != D3DDEVTYPE_NULLREF)
     {
         D3DPRESENT_PARAMETERS presentParameters = {0};
         presentParameters.AutoDepthStencilFormat = depthBufferd3dFormatInfo.renderFormat;

src/libANGLE/renderer/d3d/d3d9/formatutils9.cpp

@@ -560,7 +560,7 @@ const VertexFormat &GetVertexFormatInfo(DWORD supportedDeclTypes, const gl::Vert
     static bool initialized = false;
     static DWORD intializedDeclTypes = 0;
     static VertexFormat formatConverters[NUM_GL_VERTEX_ATTRIB_TYPES][2][4];
-    if (!initialized)
+    if (intializedDeclTypes != supportedDeclTypes)
     {
         const TranslationDescription translations[NUM_GL_VERTEX_ATTRIB_TYPES][2][4] = // [GL types as enumerated by typeIndex()][normalized][size-1]
         {
@@ -592,8 +592,6 @@ const VertexFormat &GetVertexFormatInfo(DWORD supportedDeclTypes, const gl::Vert
         intializedDeclTypes = supportedDeclTypes;
     }
 
-    ASSERT(intializedDeclTypes == supportedDeclTypes);
-
     // Pure integer attributes only supported in ES3.0
     ASSERT(!vertexFormat.mPureInteger);
     return formatConverters[ComputeTypeIndex(vertexFormat.mType)][vertexFormat.mNormalized][vertexFormat.mComponents - 1];

src/tests/perf_tests/ANGLEPerfTest.cpp

@@ -34,11 +34,16 @@ ANGLEPerfTest::ANGLEPerfTest(const std::string &name, const PerfTestParams &test
 
 void ANGLEPerfTest::SetUp()
 {
+    EGLPlatformParameters platformParams(mTestParams.requestedRenderer,
+                                         EGL_DONT_CARE,
+                                         EGL_DONT_CARE,
+                                         mTestParams.deviceType);
+
     mOSWindow.reset(CreateOSWindow());
     mEGLWindow.reset(new EGLWindow(mTestParams.widowWidth,
                                    mTestParams.windowHeight,
                                    mTestParams.glesMajorVersion,
-                                   EGLPlatformParameters(mTestParams.requestedRenderer)));
+                                   platformParams));
     mTimer.reset(CreateTimer());
 
     if (!mOSWindow->initialize(mName, mEGLWindow->getWidth(), mEGLWindow->getHeight()))

src/tests/perf_tests/ANGLEPerfTest.h

@@ -27,6 +27,7 @@ class Event;
 struct PerfTestParams
 {
     EGLint requestedRenderer;
+    EGLint deviceType;
     EGLint glesMajorVersion;
     EGLint widowWidth;
     EGLint windowHeight;

src/tests/perf_tests/BufferSubData.cpp

@@ -332,13 +332,14 @@ void BufferSubDataBenchmark::drawBenchmark()
     }
 }
 
-BufferSubDataParams D3D11Params()
+BufferSubDataParams BufferUpdateD3D11Params()
 {
     BufferSubDataParams 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.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;
@@ -349,13 +350,14 @@ BufferSubDataParams D3D11Params()
     return params;
 }
 
-BufferSubDataParams D3D9Params()
+BufferSubDataParams BufferUpdateD3D9Params()
 {
     BufferSubDataParams 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.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;
@@ -366,13 +368,53 @@ BufferSubDataParams D3D9Params()
     return params;
 }
 
+BufferSubDataParams DrawCallD3D11Params()
+{
+    BufferSubDataParams 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_NULL_ANGLE;
+    params.vertexType = GL_FLOAT;
+    params.vertexComponentCount = 4;
+    params.vertexNormalized = GL_FALSE;
+    params.updateSize = 0;
+    params.bufferSize = 100000;
+    params.iterations = 50;
+    params.updateRate = 1;
+    return params;
+}
+
+BufferSubDataParams DrawCallD3D9Params()
+{
+    BufferSubDataParams 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_NULL_ANGLE;
+    params.vertexType = GL_FLOAT;
+    params.vertexComponentCount = 4;
+    params.vertexNormalized = GL_FALSE;
+    params.updateSize = 0;
+    params.bufferSize = 100000;
+    params.iterations = 50;
+    params.updateRate = 1;
+    return params;
+}
+
 } // namespace
 
-TEST_P(BufferSubDataBenchmark, BufferUpdates)
+TEST_P(BufferSubDataBenchmark, Run)
 {
     run();
 }
 
 INSTANTIATE_TEST_CASE_P(BufferUpdates,
                         BufferSubDataBenchmark,
-                        ::testing::Values(D3D11Params(), D3D9Params()));
+                        ::testing::Values(BufferUpdateD3D11Params(), BufferUpdateD3D9Params()));
+
+INSTANTIATE_TEST_CASE_P(DrawCallPerf,
+                        BufferSubDataBenchmark,
+                        ::testing::Values(DrawCallD3D11Params(), DrawCallD3D9Params()));

src/tests/perf_tests/PointSprites.cpp

@@ -206,6 +206,7 @@ PointSpritesParams D3D11Params()
     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;
@@ -223,6 +224,7 @@ PointSpritesParams D3D9Params()
     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;
@@ -234,7 +236,7 @@ PointSpritesParams D3D9Params()
 
 } // namespace
 
-TEST_P(PointSpritesBenchmark, Render)
+TEST_P(PointSpritesBenchmark, Run)
 {
     run();
 }

src/tests/perf_tests/TexSubImage.cpp

@@ -263,6 +263,7 @@ TexSubImageParams D3D11Params()
     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;
@@ -281,6 +282,7 @@ TexSubImageParams D3D9Params()
     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;
@@ -293,7 +295,7 @@ TexSubImageParams D3D9Params()
 
 } // namespace
 
-TEST_P(TexSubImageBenchmark, TextureUpdates)
+TEST_P(TexSubImageBenchmark, Run)
 {
     run();
 }

util/EGLWindow.h

@@ -25,6 +25,12 @@
 
 class OSWindow;
 
+// A hidden define used in some renderers (currently D3D-only)
+// to init a no-op renderer. Useful for performance testing.
+#ifndef EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE
+#define EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE 0x6AC0
+#endif
+
 struct EGLPlatformParameters
 {
     EGLint renderer;