Introduced eglMakeCurrent Perf Test

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -319,6 +319,7 @@ void RendererVk::onDestroy(vk::Context *context)
         mInstance = VK_NULL_HANDLE;
     }
 
+    mMemoryProperties.destroy();
     mPhysicalDevice = VK_NULL_HANDLE;
 }
 

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -1011,6 +1011,11 @@ void MemoryProperties::init(VkPhysicalDevice physicalDevice)
     ASSERT(mMemoryProperties.memoryTypeCount > 0);
 }
 
+void MemoryProperties::destroy()
+{
+    mMemoryProperties = {0};
+}
+
 angle::Result MemoryProperties::findCompatibleMemoryIndex(
     Context *context,
     const VkMemoryRequirements &memoryRequirements,

src/libANGLE/renderer/vulkan/vk_utils.h

@@ -276,6 +276,7 @@ class MemoryProperties final : angle::NonCopyable
                                             const VkMemoryRequirements &memoryRequirements,
                                             VkMemoryPropertyFlags memoryPropertyFlags,
                                             uint32_t *indexOut) const;
+    void destroy();
 
   private:
     VkPhysicalDeviceMemoryProperties mMemoryProperties;

src/tests/angle_perftests.gypi

@@ -29,6 +29,7 @@
             '<(angle_path)/src/tests/perf_tests/DrawElementsPerf.cpp',
             '<(angle_path)/src/tests/perf_tests/DynamicPromotionPerfTest.cpp',
             '<(angle_path)/src/tests/perf_tests/EGLInitializePerf.cpp',
+            '<(angle_path)/src/tests/perf_tests/EGLMakeCurrentPerf.cpp',
             '<(angle_path)/src/tests/perf_tests/ResultPerf.cpp',
             '<(angle_path)/src/tests/perf_tests/IndexConversionPerf.cpp',
             '<(angle_path)/src/tests/perf_tests/InstancingPerf.cpp',

src/tests/perf_tests/EGLMakeCurrentPerf.cpp

+//
+// Copyright 2018 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.
+//
+// EGLMakeCurrentPerfTest:
+//   Performance test for eglMakeCurrent.
+//
+
+#include "ANGLEPerfTest.h"
+#include "platform/Platform.h"
+#include "test_utils/angle_test_configs.h"
+#include "test_utils/angle_test_instantiate.h"
+
+#define ITERATIONS 20
+
+using namespace testing;
+
+namespace
+{
+class EGLMakeCurrentPerfTest : public ANGLEPerfTest,
+                               public WithParamInterface<angle::PlatformParameters>
+{
+  public:
+    EGLMakeCurrentPerfTest();
+
+    void step() override;
+    void SetUp() override;
+    void TearDown() override;
+
+  private:
+    OSWindow *mOSWindow;
+    EGLDisplay mDisplay;
+    EGLSurface mSurface;
+    EGLConfig mConfig;
+    std::array<EGLContext, 2> mContexts;
+};
+
+EGLMakeCurrentPerfTest::EGLMakeCurrentPerfTest()
+    : ANGLEPerfTest("EGLMakeCurrent", "_run"),
+      mOSWindow(nullptr),
+      mDisplay(EGL_NO_DISPLAY),
+      mSurface(EGL_NO_SURFACE),
+      mConfig(nullptr),
+      mContexts({})
+{
+    auto platform = GetParam().eglParameters;
+
+    std::vector<EGLint> displayAttributes;
+    displayAttributes.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
+    displayAttributes.push_back(platform.renderer);
+    displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE);
+    displayAttributes.push_back(platform.majorVersion);
+    displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE);
+    displayAttributes.push_back(platform.minorVersion);
+    displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
+    displayAttributes.push_back(platform.deviceType);
+    displayAttributes.push_back(EGL_NONE);
+
+    mOSWindow = CreateOSWindow();
+    mOSWindow->initialize("EGLMakeCurrent Test", 64, 64);
+
+    mDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,
+                                        reinterpret_cast<void *>(mOSWindow->getNativeDisplay()),
+                                        &displayAttributes[0]);
+}
+
+void EGLMakeCurrentPerfTest::SetUp()
+{
+    ASSERT_NE(EGL_NO_DISPLAY, mDisplay);
+    EGLint majorVersion, minorVersion;
+    ASSERT_TRUE(eglInitialize(mDisplay, &majorVersion, &minorVersion));
+
+    EGLint numConfigs;
+    EGLint configAttrs[] = {EGL_RED_SIZE,
+                            8,
+                            EGL_GREEN_SIZE,
+                            8,
+                            EGL_BLUE_SIZE,
+                            8,
+                            EGL_RENDERABLE_TYPE,
+                            GetParam().majorVersion == 3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT,
+                            EGL_SURFACE_TYPE,
+                            EGL_PBUFFER_BIT,
+                            EGL_NONE};
+
+    ASSERT_TRUE(eglChooseConfig(mDisplay, configAttrs, &mConfig, 1, &numConfigs));
+
+    mContexts[0] = eglCreateContext(mDisplay, mConfig, EGL_NO_CONTEXT, nullptr);
+    ASSERT_NE(EGL_NO_CONTEXT, mContexts[0]);
+    mContexts[1] = eglCreateContext(mDisplay, mConfig, EGL_NO_CONTEXT, nullptr);
+    ASSERT_NE(EGL_NO_CONTEXT, mContexts[1]);
+
+    mSurface = eglCreateWindowSurface(mDisplay, mConfig, mOSWindow->getNativeWindow(), nullptr);
+    ASSERT_NE(EGL_NO_SURFACE, mSurface);
+    ASSERT_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, mContexts[0]));
+}
+
+void EGLMakeCurrentPerfTest::TearDown()
+{
+    ANGLEPerfTest::TearDown();
+    eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    eglDestroySurface(mDisplay, mSurface);
+    eglDestroyContext(mDisplay, mContexts[0]);
+    eglDestroyContext(mDisplay, mContexts[1]);
+}
+
+void EGLMakeCurrentPerfTest::step()
+{
+    int mCurrContext = 0;
+    for (int x = 0; x < ITERATIONS; x++)
+    {
+        mCurrContext = (mCurrContext + 1) % mContexts.size();
+        eglMakeCurrent(mDisplay, mSurface, mSurface, mContexts[mCurrContext]);
+    }
+}
+
+TEST_P(EGLMakeCurrentPerfTest, Run)
+{
+    run();
+}
+
+#if !defined(ANGLE_PLATFORM_ANDROID)
+ANGLE_INSTANTIATE_TEST(EGLMakeCurrentPerfTest,
+                       angle::ES2_D3D9(),
+                       angle::ES2_D3D11(),
+                       angle::ES2_OPENGL(),
+                       angle::ES2_OPENGLES(),
+                       angle::ES2_VULKAN());
+#else
+ANGLE_INSTANTIATE_TEST(EGLMakeCurrentPerfTest, angle::ES2_D3D9(), angle::ES2_D3D11());
+#endif
+
+}  // namespace

util/EGLWindow.cpp

@@ -20,7 +20,7 @@ EGLPlatformParameters::EGLPlatformParameters()
     : renderer(EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE),
       majorVersion(EGL_DONT_CARE),
       minorVersion(EGL_DONT_CARE),
-      deviceType(EGL_DONT_CARE),
+      deviceType(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE),
       presentPath(EGL_DONT_CARE)
 {
 }
@@ -29,24 +29,19 @@ EGLPlatformParameters::EGLPlatformParameters(EGLint renderer)
     : renderer(renderer),
       majorVersion(EGL_DONT_CARE),
       minorVersion(EGL_DONT_CARE),
-      deviceType(EGL_DONT_CARE),
+      deviceType(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE),
       presentPath(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)
+                                             EGLint deviceType)
     : renderer(renderer),
       majorVersion(majorVersion),
       minorVersion(minorVersion),
-      deviceType(useWarp),
+      deviceType(deviceType),
       presentPath(EGL_DONT_CARE)
 {
 }
@@ -54,12 +49,12 @@ EGLPlatformParameters::EGLPlatformParameters(EGLint renderer,
 EGLPlatformParameters::EGLPlatformParameters(EGLint renderer,
                                              EGLint majorVersion,
                                              EGLint minorVersion,
-                                             EGLint useWarp,
+                                             EGLint deviceType,
                                              EGLint presentPath)
     : renderer(renderer),
       majorVersion(majorVersion),
       minorVersion(minorVersion),
-      deviceType(useWarp),
+      deviceType(deviceType),
       presentPath(presentPath)
 {
 }