Run angle_perftests on GLES backend

src/tests/perf_tests/BindingPerf.cpp

@@ -184,10 +184,10 @@ BindingsParams D3D9Params(AllocationStyle allocationStyle)
     return params;
 }
 
-BindingsParams OpenGLParams(AllocationStyle allocationStyle)
+BindingsParams OpenGLOrGLESParams(AllocationStyle allocationStyle)
 {
     BindingsParams params;
-    params.eglParameters   = egl_platform::OPENGL_NULL();
+    params.eglParameters   = egl_platform::OPENGL_OR_GLES(true);
     params.allocationStyle = allocationStyle;
     return params;
 }
@@ -202,7 +202,7 @@ ANGLE_INSTANTIATE_TEST(BindingsBenchmark,
                        D3D11Params(AT_INITIALIZATION),
                        D3D9Params(EVERY_ITERATION),
                        D3D9Params(AT_INITIALIZATION),
-                       OpenGLParams(EVERY_ITERATION),
-                       OpenGLParams(AT_INITIALIZATION));
+                       OpenGLOrGLESParams(EVERY_ITERATION),
+                       OpenGLOrGLESParams(AT_INITIALIZATION));
 
 }  // namespace angle

src/tests/perf_tests/BufferSubData.cpp

@@ -368,10 +368,10 @@ BufferSubDataParams BufferUpdateD3D9Params()
     return params;
 }
 
-BufferSubDataParams BufferUpdateOpenGLParams()
+BufferSubDataParams BufferUpdateOpenGLOrGLESParams()
 {
     BufferSubDataParams params;
-    params.eglParameters = egl_platform::OPENGL();
+    params.eglParameters        = egl_platform::OPENGL_OR_GLES(false);
     params.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;
@@ -384,7 +384,8 @@ TEST_P(BufferSubDataBenchmark, Run)
 }
 
 ANGLE_INSTANTIATE_TEST(BufferSubDataBenchmark,
-                       BufferUpdateD3D11Params(), BufferUpdateD3D9Params(),
-                       BufferUpdateOpenGLParams());
+                       BufferUpdateD3D11Params(),
+                       BufferUpdateD3D9Params(),
+                       BufferUpdateOpenGLOrGLESParams());
 
 } // namespace

src/tests/perf_tests/DrawCallPerf.cpp

@@ -106,9 +106,9 @@ ANGLE_INSTANTIATE_TEST(DrawCallPerfBenchmark,
                        DrawCallPerfD3D11Params(false, false),
                        DrawCallPerfD3D11Params(true, false),
                        DrawCallPerfD3D11Params(true, true),
-                       DrawCallPerfOpenGLParams(false, false),
-                       DrawCallPerfOpenGLParams(true, false),
-                       DrawCallPerfOpenGLParams(true, true),
+                       DrawCallPerfOpenGLOrGLESParams(false, false),
+                       DrawCallPerfOpenGLOrGLESParams(true, false),
+                       DrawCallPerfOpenGLOrGLESParams(true, true),
                        DrawCallPerfValidationOnly(),
                        DrawCallPerfVulkanParams(false));
 

src/tests/perf_tests/DrawCallPerfParams.cpp

@@ -59,10 +59,10 @@ DrawCallPerfParams DrawCallPerfD3D9Params(bool useNullDevice, bool renderToTextu
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfOpenGLParams(bool useNullDevice, bool renderToTexture)
+DrawCallPerfParams DrawCallPerfOpenGLOrGLESParams(bool useNullDevice, bool renderToTexture)
 {
     DrawCallPerfParams params;
-    params.eglParameters = useNullDevice ? OPENGL_NULL() : OPENGL();
+    params.eglParameters = OPENGL_OR_GLES(useNullDevice);
     params.useFBO        = renderToTexture;
     return params;
 }

src/tests/perf_tests/DrawCallPerfParams.h

@@ -40,7 +40,7 @@ DrawCallPerfParams DrawCallPerfD3D11Params(bool useNullDevice, bool renderToText
 
 DrawCallPerfParams DrawCallPerfD3D9Params(bool useNullDevice, bool renderToTexture);
 
-DrawCallPerfParams DrawCallPerfOpenGLParams(bool useNullDevice, bool renderToTexture);
+DrawCallPerfParams DrawCallPerfOpenGLOrGLESParams(bool useNullDevice, bool renderToTexture);
 
 DrawCallPerfParams DrawCallPerfValidationOnly();
 

src/tests/perf_tests/DrawElementsPerf.cpp

@@ -175,10 +175,10 @@ DrawElementsPerfParams DrawElementsPerfD3D9Params(bool indexBufferChanged)
     return params;
 }
 
-DrawElementsPerfParams DrawElementsPerfOpenGLParams(bool indexBufferChanged)
+DrawElementsPerfParams DrawElementsPerfOpenGLOrGLESParams(bool indexBufferChanged)
 {
     DrawElementsPerfParams params;
-    params.eglParameters      = angle::egl_platform::OPENGL();
+    params.eglParameters      = angle::egl_platform::OPENGL_OR_GLES(false);
     params.indexBufferChanged = indexBufferChanged;
     return params;
 }
@@ -195,7 +195,7 @@ ANGLE_INSTANTIATE_TEST(DrawElementsPerfBenchmark,
                        DrawElementsPerfD3D11Params(true, true),
                        DrawElementsPerfD3D11Params(false, false),
                        DrawElementsPerfD3D11Params(true, false),
-                       DrawElementsPerfOpenGLParams(false),
-                       DrawElementsPerfOpenGLParams(true));
+                       DrawElementsPerfOpenGLOrGLESParams(false),
+                       DrawElementsPerfOpenGLOrGLESParams(true));
 
 }  // namespace

src/tests/perf_tests/InstancingPerf.cpp

@@ -344,10 +344,10 @@ InstancingPerfParams InstancingPerfD3D9Params()
     return params;
 }
 
-InstancingPerfParams InstancingPerfOpenGLParams()
+InstancingPerfParams InstancingPerfOpenGLOrGLESParams()
 {
     InstancingPerfParams params;
-    params.eglParameters = OPENGL();
+    params.eglParameters = OPENGL_OR_GLES(false);
     return params;
 }
 
@@ -359,6 +359,6 @@ TEST_P(InstancingPerfBenchmark, Run)
 ANGLE_INSTANTIATE_TEST(InstancingPerfBenchmark,
                        InstancingPerfD3D11Params(),
                        InstancingPerfD3D9Params(),
-                       InstancingPerfOpenGLParams());
+                       InstancingPerfOpenGLOrGLESParams());
 
 }  // anonymous namespace

src/tests/perf_tests/InterleavedAttributeData.cpp

@@ -215,10 +215,10 @@ InterleavedAttributeDataParams D3D9Params()
     return params;
 }
 
-InterleavedAttributeDataParams OpenGLParams()
+InterleavedAttributeDataParams OpenGLOrGLESParams()
 {
     InterleavedAttributeDataParams params;
-    params.eglParameters = egl_platform::OPENGL();
+    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
     return params;
 }
 
@@ -226,6 +226,6 @@ ANGLE_INSTANTIATE_TEST(InterleavedAttributeDataBenchmark,
                        D3D11Params(),
                        D3D11_9_3Params(),
                        D3D9Params(),
-                       OpenGLParams());
+                       OpenGLOrGLESParams());
 
 }  // anonymous namespace

src/tests/perf_tests/LinkProgramPerfTest.cpp

@@ -128,10 +128,10 @@ LinkProgramParams LinkProgramD3D9Params()
     return params;
 }
 
-LinkProgramParams LinkProgramOpenGLParams()
+LinkProgramParams LinkProgramOpenGLOrGLESParams()
 {
     LinkProgramParams params;
-    params.eglParameters = OPENGL();
+    params.eglParameters = OPENGL_OR_GLES(false);
     return params;
 }
 
@@ -143,6 +143,6 @@ TEST_P(LinkProgramBenchmark, Run)
 ANGLE_INSTANTIATE_TEST(LinkProgramBenchmark,
                        LinkProgramD3D11Params(),
                        LinkProgramD3D9Params(),
-                       LinkProgramOpenGLParams());
+                       LinkProgramOpenGLOrGLESParams());
 
 }  // anonymous namespace

src/tests/perf_tests/MultiviewPerf.cpp

@@ -514,10 +514,11 @@ TEST_P(MultiviewCPUBoundBenchmark, Run)
 }
 
 ANGLE_INSTANTIATE_TEST(MultiviewCPUBoundBenchmark,
-                       NoAcceleration(egl_platform::OPENGL(), SmallWorkload()),
+                       NoAcceleration(egl_platform::OPENGL_OR_GLES(false), SmallWorkload()),
                        NoAcceleration(egl_platform::D3D11(), SmallWorkload()),
                        SelectViewInGeometryShader(SmallWorkload()),
-                       SelectViewInVertexShader(egl_platform::OPENGL(), SmallWorkload()),
+                       SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(false),
+                                                SmallWorkload()),
                        SelectViewInVertexShader(egl_platform::D3D11(), SmallWorkload()));
 
 TEST_P(MultiviewGPUBoundBenchmark, Run)
@@ -526,10 +527,10 @@ TEST_P(MultiviewGPUBoundBenchmark, Run)
 }
 
 ANGLE_INSTANTIATE_TEST(MultiviewGPUBoundBenchmark,
-                       NoAcceleration(egl_platform::OPENGL(), BigWorkload()),
+                       NoAcceleration(egl_platform::OPENGL_OR_GLES(false), BigWorkload()),
                        NoAcceleration(egl_platform::D3D11(), BigWorkload()),
                        SelectViewInGeometryShader(BigWorkload()),
-                       SelectViewInVertexShader(egl_platform::OPENGL(), BigWorkload()),
+                       SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(false), BigWorkload()),
                        SelectViewInVertexShader(egl_platform::D3D11(), BigWorkload()));
 
-}  // anonymous namespace
+}  // anonymous namespace
\ No newline at end of file

src/tests/perf_tests/PointSprites.cpp

@@ -212,10 +212,10 @@ PointSpritesParams D3D9Params()
     return params;
 }
 
-PointSpritesParams OpenGLParams()
+PointSpritesParams OpenGLOrGLESParams()
 {
     PointSpritesParams params;
-    params.eglParameters = egl_platform::OPENGL();
+    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
     return params;
 }
 
@@ -226,5 +226,4 @@ TEST_P(PointSpritesBenchmark, Run)
     run();
 }
 
-ANGLE_INSTANTIATE_TEST(PointSpritesBenchmark,
-                       D3D11Params(), D3D9Params(), OpenGLParams());
+ANGLE_INSTANTIATE_TEST(PointSpritesBenchmark, D3D11Params(), D3D9Params(), OpenGLOrGLESParams());

src/tests/perf_tests/TexSubImage.cpp

@@ -90,7 +90,7 @@ std::string TexSubImageParams::suffix() const
 }
 
 TexSubImageBenchmark::TexSubImageBenchmark()
-    : ANGLERenderTest("TexSubImage", GetParam()),
+    : ANGLERenderTest("TexSubImage", GetParam(), {"GL_EXT_texture_storage"}),
       mProgram(0),
       mPositionLoc(-1),
       mTexCoordLoc(-1),
@@ -274,10 +274,10 @@ TexSubImageParams D3D9Params()
     return params;
 }
 
-TexSubImageParams OpenGLParams()
+TexSubImageParams OpenGLOrGLESParams()
 {
     TexSubImageParams params;
-    params.eglParameters = egl_platform::OPENGL();
+    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
     return params;
 }
 
@@ -288,4 +288,4 @@ TEST_P(TexSubImageBenchmark, Run)
     run();
 }
 
-ANGLE_INSTANTIATE_TEST(TexSubImageBenchmark, D3D11Params(), D3D9Params(), OpenGLParams());
+ANGLE_INSTANTIATE_TEST(TexSubImageBenchmark, D3D11Params(), D3D9Params(), OpenGLOrGLESParams());

src/tests/perf_tests/TextureSampling.cpp

@@ -271,10 +271,10 @@ TextureSamplingParams D3D9Params()
     return params;
 }
 
-TextureSamplingParams OpenGLParams()
+TextureSamplingParams OpenGLOrGLESParams()
 {
     TextureSamplingParams params;
-    params.eglParameters = egl_platform::OPENGL();
+    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
     return params;
 }
 
@@ -285,4 +285,4 @@ TEST_P(TextureSamplingBenchmark, Run)
     run();
 }
 
-ANGLE_INSTANTIATE_TEST(TextureSamplingBenchmark, D3D11Params(), D3D9Params(), OpenGLParams());
+ANGLE_INSTANTIATE_TEST(TextureSamplingBenchmark, D3D11Params(), D3D9Params(), OpenGLOrGLESParams());

src/tests/perf_tests/TexturesPerf.cpp

@@ -276,10 +276,10 @@ TexturesParams D3D9Params()
     return params;
 }
 
-TexturesParams OpenGLParams()
+TexturesParams OpenGLOrGLESParams()
 {
     TexturesParams params;
-    params.eglParameters = egl_platform::OPENGL_NULL();
+    params.eglParameters = egl_platform::OPENGL_OR_GLES(true);
     return params;
 }
 
@@ -288,6 +288,6 @@ TEST_P(TexturesBenchmark, Run)
     run();
 }
 
-ANGLE_INSTANTIATE_TEST(TexturesBenchmark, D3D11Params(), D3D9Params(), OpenGLParams());
+ANGLE_INSTANTIATE_TEST(TexturesBenchmark, D3D11Params(), D3D9Params(), OpenGLOrGLESParams());
 
 }  // namespace angle

src/tests/perf_tests/UniformsPerf.cpp

@@ -396,8 +396,8 @@ UniformsParams MatrixUniforms(const EGLPlatformParameters &egl, DataMode dataMod
     params.dataMode      = dataMode;
 
     // Reduce the number of uniforms to fit within smaller upper limits on some configs.
-    params.numVertexUniforms   = 100;
-    params.numFragmentUniforms = 100;
+    params.numVertexUniforms   = 64;
+    params.numFragmentUniforms = 64;
 
     return params;
 }
@@ -414,9 +414,9 @@ ANGLE_INSTANTIATE_TEST(UniformsBenchmark,
                        VectorUniforms(D3D11(), DataMode::REPEAT),
                        VectorUniforms(D3D11(), DataMode::UPDATE),
                        VectorUniforms(D3D11_NULL(), DataMode::UPDATE),
-                       VectorUniforms(OPENGL(), DataMode::UPDATE),
-                       VectorUniforms(OPENGL(), DataMode::REPEAT),
-                       VectorUniforms(OPENGL_NULL(), DataMode::UPDATE),
+                       VectorUniforms(OPENGL_OR_GLES(false), DataMode::UPDATE),
+                       VectorUniforms(OPENGL_OR_GLES(false), DataMode::REPEAT),
+                       VectorUniforms(OPENGL_OR_GLES(true), DataMode::UPDATE),
                        MatrixUniforms(D3D11(), DataMode::UPDATE),
-                       MatrixUniforms(OPENGL(), DataMode::UPDATE),
+                       MatrixUniforms(OPENGL_OR_GLES(false), DataMode::UPDATE),
                        VectorUniforms(D3D11_NULL(), DataMode::REPEAT, ProgramMode::MULTIPLE));

src/tests/test_utils/angle_test_configs.cpp

@@ -373,6 +373,21 @@ EGLPlatformParameters OPENGLES(EGLint major, EGLint minor)
                                  EGL_DONT_CARE);
 }
 
+EGLPlatformParameters OPENGLES_NULL()
+{
+    return EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE, EGL_DONT_CARE,
+                                 EGL_DONT_CARE, EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE);
+}
+
+EGLPlatformParameters OPENGL_OR_GLES(bool useNullDevice)
+{
+#if defined(ANGLE_PLATFORM_ANDROID)
+    return useNullDevice ? OPENGLES_NULL() : OPENGLES();
+#else
+    return useNullDevice ? OPENGL_NULL() : OPENGL();
+#endif
+}
+
 EGLPlatformParameters VULKAN()
 {
     return EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE);

src/tests/test_utils/angle_test_configs.h

@@ -81,6 +81,9 @@ EGLPlatformParameters OPENGL_NULL();
 
 EGLPlatformParameters OPENGLES();
 EGLPlatformParameters OPENGLES(EGLint major, EGLint minor);
+EGLPlatformParameters OPENGLES_NULL();
+
+EGLPlatformParameters OPENGL_OR_GLES(bool useNullDevice);
 
 EGLPlatformParameters VULKAN();