Enabled Vulkan backend on as many tests as possible

src/tests/perf_tests/BindingPerf.cpp

@@ -192,6 +192,14 @@ BindingsParams OpenGLOrGLESParams(AllocationStyle allocationStyle)
     return params;
 }
 
+BindingsParams VulkanParams(AllocationStyle allocationStyle)
+{
+    BindingsParams params;
+    params.eglParameters   = egl_platform::VULKAN_NULL();
+    params.allocationStyle = allocationStyle;
+    return params;
+}
+
 TEST_P(BindingsBenchmark, Run)
 {
     run();
@@ -203,6 +211,8 @@ ANGLE_INSTANTIATE_TEST(BindingsBenchmark,
                        D3D9Params(EVERY_ITERATION),
                        D3D9Params(AT_INITIALIZATION),
                        OpenGLOrGLESParams(EVERY_ITERATION),
-                       OpenGLOrGLESParams(AT_INITIALIZATION));
+                       OpenGLOrGLESParams(AT_INITIALIZATION),
+                       VulkanParams(EVERY_ITERATION),
+                       VulkanParams(AT_INITIALIZATION));
 
 }  // namespace angle

src/tests/perf_tests/BlitFramebufferPerf.cpp

@@ -236,6 +236,15 @@ BlitFramebufferParams D3D11(BufferType type, unsigned int samples)
     return params;
 }
 
+BlitFramebufferParams Vulkan(BufferType type, unsigned int samples)
+{
+    BlitFramebufferParams params;
+    params.eglParameters = angle::egl_platform::VULKAN();
+    params.type          = type;
+    params.samples       = samples;
+    return params;
+}
+
 }  // anonymous namespace
 
 // TODO(jmadill): Programatically generate these combinations.
@@ -247,4 +256,12 @@ ANGLE_INSTANTIATE_TEST(BlitFramebufferPerf,
                        D3D11(BufferType::COLOR, 2),
                        D3D11(BufferType::DEPTH, 2),
                        D3D11(BufferType::STENCIL, 2),
-                       D3D11(BufferType::DEPTH_STENCIL, 2))
+                       D3D11(BufferType::DEPTH_STENCIL, 2),
+                       Vulkan(BufferType::COLOR, 0),
+                       Vulkan(BufferType::DEPTH, 0),
+                       Vulkan(BufferType::STENCIL, 0),
+                       Vulkan(BufferType::DEPTH_STENCIL, 0),
+                       Vulkan(BufferType::COLOR, 2),
+                       Vulkan(BufferType::DEPTH, 2),
+                       Vulkan(BufferType::STENCIL, 2),
+                       Vulkan(BufferType::DEPTH_STENCIL, 2))

src/tests/perf_tests/BufferSubData.cpp

@@ -378,6 +378,16 @@ BufferSubDataParams BufferUpdateOpenGLOrGLESParams()
     return params;
 }
 
+BufferSubDataParams BufferUpdateVulkanParams()
+{
+    BufferSubDataParams params;
+    params.eglParameters        = egl_platform::VULKAN();
+    params.vertexType           = GL_FLOAT;
+    params.vertexComponentCount = 4;
+    params.vertexNormalized     = GL_FALSE;
+    return params;
+}
+
 TEST_P(BufferSubDataBenchmark, Run)
 {
     run();
@@ -386,6 +396,7 @@ TEST_P(BufferSubDataBenchmark, Run)
 ANGLE_INSTANTIATE_TEST(BufferSubDataBenchmark,
                        BufferUpdateD3D11Params(),
                        BufferUpdateD3D9Params(),
-                       BufferUpdateOpenGLOrGLESParams());
+                       BufferUpdateOpenGLOrGLESParams(),
+                       BufferUpdateVulkanParams());
 
 } // namespace

src/tests/perf_tests/DispatchComputePerf.cpp

@@ -164,6 +164,14 @@ DispatchComputePerfParams DispatchComputePerfOpenGLOrGLESParams(bool useNullDevi
     return params;
 }
 
+DispatchComputePerfParams DispatchComputePerfVulkanParams(bool useNullDevice)
+{
+    DispatchComputePerfParams params;
+    params.eglParameters =
+        useNullDevice ? angle::egl_platform::VULKAN() : angle::egl_platform::VULKAN_NULL();
+    return params;
+}
+
 TEST_P(DispatchComputePerfBenchmark, Run)
 {
     run();
@@ -171,6 +179,8 @@ TEST_P(DispatchComputePerfBenchmark, Run)
 
 ANGLE_INSTANTIATE_TEST(DispatchComputePerfBenchmark,
                        DispatchComputePerfOpenGLOrGLESParams(true),
-                       DispatchComputePerfOpenGLOrGLESParams(false));
+                       DispatchComputePerfOpenGLOrGLESParams(false),
+                       DispatchComputePerfVulkanParams(true),
+                       DispatchComputePerfVulkanParams(false));
 
 }  // namespace

src/tests/perf_tests/DynamicPromotionPerfTest.cpp

@@ -177,6 +177,13 @@ DynamicPromotionParams DynamicPromotionD3D9Params()
     return params;
 }
 
+DynamicPromotionParams DynamicPromotionVulkanParams()
+{
+    DynamicPromotionParams params;
+    params.eglParameters = egl_platform::VULKAN();
+    return params;
+}
+
 TEST_P(DynamicPromotionPerfTest, Run)
 {
     run();
@@ -184,6 +191,7 @@ TEST_P(DynamicPromotionPerfTest, Run)
 
 ANGLE_INSTANTIATE_TEST(DynamicPromotionPerfTest,
                        DynamicPromotionD3D11Params(),
-                       DynamicPromotionD3D9Params());
+                       DynamicPromotionD3D9Params(),
+                       DynamicPromotionVulkanParams());
 
 }  // anonymous namespace

src/tests/perf_tests/EGLInitializePerf.cpp

@@ -154,6 +154,6 @@ TEST_P(EGLInitializePerfTest, Run)
     run();
 }
 
-ANGLE_INSTANTIATE_TEST(EGLInitializePerfTest, angle::ES2_D3D11());
+ANGLE_INSTANTIATE_TEST(EGLInitializePerfTest, angle::ES2_D3D11(), angle::ES2_VULKAN());
 
 } // namespace

src/tests/perf_tests/IndexConversionPerf.cpp

@@ -223,5 +223,4 @@ TEST_P(IndexConversionPerfTest, Run)
 ANGLE_INSTANTIATE_TEST(IndexConversionPerfTest,
                        IndexConversionPerfD3D11Params(),
                        IndexRangeOffsetPerfD3D11Params());
-
 }  // namespace

src/tests/perf_tests/InterleavedAttributeData.cpp

@@ -225,10 +225,18 @@ InterleavedAttributeDataParams OpenGLOrGLESParams()
     return params;
 }
 
+InterleavedAttributeDataParams VulkanParams()
+{
+    InterleavedAttributeDataParams params;
+    params.eglParameters = egl_platform::VULKAN();
+    return params;
+}
+
 ANGLE_INSTANTIATE_TEST(InterleavedAttributeDataBenchmark,
                        D3D11Params(),
                        D3D11_9_3Params(),
                        D3D9Params(),
-                       OpenGLOrGLESParams());
+                       OpenGLOrGLESParams(),
+                       VulkanParams());
 
 }  // anonymous namespace

src/tests/perf_tests/LinkProgramPerfTest.cpp

@@ -135,6 +135,13 @@ LinkProgramParams LinkProgramOpenGLOrGLESParams()
     return params;
 }
 
+LinkProgramParams LinkProgramVulkanParams()
+{
+    LinkProgramParams params;
+    params.eglParameters = VULKAN();
+    return params;
+}
+
 TEST_P(LinkProgramBenchmark, Run)
 {
     run();
@@ -143,6 +150,7 @@ TEST_P(LinkProgramBenchmark, Run)
 ANGLE_INSTANTIATE_TEST(LinkProgramBenchmark,
                        LinkProgramD3D11Params(),
                        LinkProgramD3D9Params(),
-                       LinkProgramOpenGLOrGLESParams());
+                       LinkProgramOpenGLOrGLESParams(),
+                       LinkProgramVulkanParams());
 
 }  // anonymous namespace

src/tests/perf_tests/PointSprites.cpp

@@ -219,6 +219,13 @@ PointSpritesParams OpenGLOrGLESParams()
     return params;
 }
 
+PointSpritesParams VulkanParams()
+{
+    PointSpritesParams params;
+    params.eglParameters = egl_platform::VULKAN();
+    return params;
+}
+
 } // namespace
 
 TEST_P(PointSpritesBenchmark, Run)
@@ -226,4 +233,8 @@ TEST_P(PointSpritesBenchmark, Run)
     run();
 }
 
-ANGLE_INSTANTIATE_TEST(PointSpritesBenchmark, D3D11Params(), D3D9Params(), OpenGLOrGLESParams());
+ANGLE_INSTANTIATE_TEST(PointSpritesBenchmark,
+                       D3D11Params(),
+                       D3D9Params(),
+                       OpenGLOrGLESParams(),
+                       VulkanParams());

src/tests/perf_tests/TexSubImage.cpp

@@ -281,6 +281,13 @@ TexSubImageParams OpenGLOrGLESParams()
     return params;
 }
 
+TexSubImageParams VulkanParams()
+{
+    TexSubImageParams params;
+    params.eglParameters = egl_platform::VULKAN();
+    return params;
+}
+
 }  // namespace
 
 TEST_P(TexSubImageBenchmark, Run)
@@ -288,4 +295,8 @@ TEST_P(TexSubImageBenchmark, Run)
     run();
 }
 
-ANGLE_INSTANTIATE_TEST(TexSubImageBenchmark, D3D11Params(), D3D9Params(), OpenGLOrGLESParams());
+ANGLE_INSTANTIATE_TEST(TexSubImageBenchmark,
+                       D3D11Params(),
+                       D3D9Params(),
+                       OpenGLOrGLESParams(),
+                       VulkanParams());

src/tests/perf_tests/TextureSampling.cpp

@@ -278,6 +278,13 @@ TextureSamplingParams OpenGLOrGLESParams()
     return params;
 }
 
+TextureSamplingParams VulkanParams()
+{
+    TextureSamplingParams params;
+    params.eglParameters = egl_platform::VULKAN();
+    return params;
+}
+
 }  // anonymous namespace
 
 TEST_P(TextureSamplingBenchmark, Run)
@@ -285,4 +292,8 @@ TEST_P(TextureSamplingBenchmark, Run)
     run();
 }
 
-ANGLE_INSTANTIATE_TEST(TextureSamplingBenchmark, D3D11Params(), D3D9Params(), OpenGLOrGLESParams());
+ANGLE_INSTANTIATE_TEST(TextureSamplingBenchmark,
+                       D3D11Params(),
+                       D3D9Params(),
+                       OpenGLOrGLESParams(),
+                       VulkanParams());

src/tests/perf_tests/TexturesPerf.cpp

@@ -308,5 +308,4 @@ ANGLE_INSTANTIATE_TEST(TexturesBenchmark,
                        D3D9Params(true),
                        OpenGLOrGLESParams(false),
                        OpenGLOrGLESParams(true));
-
 }  // namespace angle