kc3-lang/angle/src/tests/egl_tests/EGLSyncTestMetalSharedEvent.mm

• Show log

  Commit

• Hash : d2a58f00
  Author :
  Date : 2022-09-08T14:19:21
  

  EGL: Implement eglCopyMetalSharedEventANGLE
  
  Add eglCopyMetalSharedEventANGLE function to the
  ANGLE_metal_shared_event_sync extension. This brings the extension on
  par with the EGL_ANDROID_native_fence_sync extension.
  
  eglCopyMetalSharedEventANGLE allows for copying the Metal event object
  from EGLSync objects implemented by the ANGLE Metal renderer. This
  function follows Objective-C convention for "copy" methods and increases
  the retain count of the Metal event object. The EGL API user is thus
  responsible for ensuring to release the returned object to avoid memory
  leaks.
  
  Test: angle_end2end_tests --gtest_filter=EGLSyncTestMetalSharedEvent.*
  Bug: angleproject:7561
  Change-Id: I8c35b559014b85cb8c6a0e76ac2ab7891eed5da0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3881423
  Reviewed-by: Kenneth Russell <kbr@chromium.org>
  Commit-Queue: Kenneth Russell <kbr@chromium.org>
  Reviewed-by: Quyen Le <lehoangquyen@chromium.org>
  

Download

• src/tests/egl_tests/EGLSyncTestMetalSharedEvent.mm

• //
  // Copyright 2022 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.
  //
  // EGLSyncTestMetalSharedEvent:
  //   Tests pertaining to EGL_ANGLE_sync_mtl_shared_event extension.
  //
  
  #include <gtest/gtest.h>
  
  #include "test_utils/ANGLETest.h"
  #include "util/EGLWindow.h"
  
  #include <Metal/Metal.h>
  
  using namespace angle;
  
  static inline EGLAttrib Uint64HighPart(uint64_t value)
  {
      return value >> 32;
  }
  
  static inline EGLAttrib Uint64LowPart(uint64_t value)
  {
      return value & 0xFFFFFFFF;
  }
  
  class EGLSyncTestMetalSharedEvent : public ANGLETest<>
  {
    protected:
      id<MTLSharedEvent> createMetalSharedEvent() const
      {
          id<MTLDevice> device           = getMetalDevice();
          id<MTLSharedEvent> sharedEvent = [device newSharedEvent];
          sharedEvent.label              = @"TestSharedEvent";
          return sharedEvent;
      }
  
      id<MTLDevice> getMetalDevice() const
      {
          EGLAttrib angleDevice = 0;
          EXPECT_EGL_TRUE(
              eglQueryDisplayAttribEXT(getEGLWindow()->getDisplay(), EGL_DEVICE_EXT, &angleDevice));
  
          EGLAttrib device = 0;
          EXPECT_EGL_TRUE(eglQueryDeviceAttribEXT(reinterpret_cast<EGLDeviceEXT>(angleDevice),
                                                  EGL_METAL_DEVICE_ANGLE, &device));
  
          return (__bridge id<MTLDevice>)reinterpret_cast<void *>(device);
      }
  
      bool hasEGLDisplayExtension(const char *extname) const
      {
          return IsEGLDisplayExtensionEnabled(getEGLWindow()->getDisplay(), extname);
      }
  
      bool hasSyncMetalSharedEventExtension() const
      {
          return hasEGLDisplayExtension("EGL_ANGLE_metal_shared_event_sync");
      }
  
      EGLAttrib sharedEventAsAttrib(id<MTLSharedEvent> sharedEvent) const
      {
          return reinterpret_cast<EGLAttrib>(sharedEvent);
      }
  
      id<MTLSharedEvent> sharedEventFromVoidPtr(void *ptr) const
      {
          return (__bridge id<MTLSharedEvent>)ptr;
      }
  };
  
  // Test existing fence is created unsignaled
  TEST_P(EGLSyncTestMetalSharedEvent, BasicEGLSync)
  {
      ANGLE_SKIP_TEST_IF(!hasSyncMetalSharedEventExtension());
  
      EGLDisplay display = getEGLWindow()->getDisplay();
  
      EGLSyncKHR sync = eglCreateSyncKHR(display, EGL_SYNC_FENCE_KHR, nullptr);
      EXPECT_NE(sync, EGL_NO_SYNC_KHR);
  
      constexpr EGLint kSentinelAttribValue = 123456789;
      EGLint signaledValue                  = kSentinelAttribValue;
      EXPECT_EGL_TRUE(eglGetSyncAttribKHR(display, sync, EGL_SYNC_STATUS_KHR, &signaledValue));
      EXPECT_EQ(signaledValue, EGL_UNSIGNALED_KHR);
  
      glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
  
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_EGL_TRUE(eglWaitSyncKHR(display, sync, 0));
  
      glFinish();
  
      // Don't wait forever to make sure the test terminates
      constexpr GLuint64 kTimeout = 1'000'000'000;  // 1 second
      EXPECT_EQ(EGL_CONDITION_SATISFIED_KHR,
                eglClientWaitSyncKHR(display, sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, kTimeout));
  
      signaledValue = kSentinelAttribValue;
      EXPECT_EGL_TRUE(eglGetSyncAttribKHR(display, sync, EGL_SYNC_STATUS_KHR, &signaledValue));
      EXPECT_EQ(signaledValue, EGL_SIGNALED_KHR);
  
      EXPECT_EGL_TRUE(eglDestroySyncKHR(display, sync));
  }
  
  // Test usage of eglGetSyncAttrib
  TEST_P(EGLSyncTestMetalSharedEvent, GetSyncAttrib)
  {
      ANGLE_SKIP_TEST_IF(!hasSyncMetalSharedEventExtension());
  
      id<MTLSharedEvent> sharedEvent = createMetalSharedEvent();
      EXPECT_EQ([sharedEvent retainCount], 1ul);
      uint64_t initialSignalValue = sharedEvent.signaledValue;
      EXPECT_EQ(initialSignalValue, 0u);
  
      EGLDisplay display      = getEGLWindow()->getDisplay();
      EGLAttrib syncAttribs[] = {EGL_SYNC_METAL_SHARED_EVENT_OBJECT_ANGLE,
                                 sharedEventAsAttrib(sharedEvent), EGL_NONE};
      EXPECT_EQ([sharedEvent retainCount], 1ul);
  
      EGLSync sync = eglCreateSync(display, EGL_SYNC_METAL_SHARED_EVENT_ANGLE, syncAttribs);
      EXPECT_NE(sync, EGL_NO_SYNC);
      // sharedEvent, sync, mtlCommandBuffer
      EXPECT_EQ([sharedEvent retainCount], 3ul);
  
      // Fence sync attributes are:
      //
      // EGL_SYNC_TYPE: EGL_SYNC_METAL_SHARED_EVENT_ANGLE
      // EGL_SYNC_STATUS: EGL_UNSIGNALED or EGL_SIGNALED
      // EGL_SYNC_CONDITION: EGL_SYNC_PRIOR_COMMANDS_COMPLETE
  
      constexpr EGLAttrib kSentinelAttribValue = 123456789;
      EGLAttrib attribValue                    = kSentinelAttribValue;
      EXPECT_EGL_TRUE(eglGetSyncAttrib(display, sync, EGL_SYNC_TYPE, &attribValue));
      EXPECT_EQ(attribValue, EGL_SYNC_METAL_SHARED_EVENT_ANGLE);
  
      attribValue = kSentinelAttribValue;
      EXPECT_EGL_TRUE(eglGetSyncAttrib(display, sync, EGL_SYNC_CONDITION, &attribValue));
      EXPECT_EQ(attribValue, EGL_SYNC_PRIOR_COMMANDS_COMPLETE);
  
      attribValue = kSentinelAttribValue;
      EXPECT_EGL_TRUE(eglGetSyncAttrib(display, sync, EGL_SYNC_STATUS, &attribValue));
      EXPECT_EQ(attribValue, EGL_UNSIGNALED);
      EXPECT_EQ([sharedEvent retainCount], 3ul);
  
      glFinish();
  
      attribValue = kSentinelAttribValue;
      EXPECT_EGL_TRUE(eglGetSyncAttrib(display, sync, EGL_SYNC_STATUS, &attribValue));
      EXPECT_EQ(attribValue, EGL_SIGNALED);
      EXPECT_EQ(sharedEvent.signaledValue, initialSignalValue + 1);
      EXPECT_EQ([sharedEvent retainCount], 2ul);
  
      EXPECT_EGL_TRUE(eglDestroySync(display, sync));
      EXPECT_EQ([sharedEvent retainCount], 1ul);
  
      sharedEvent = nil;
  }
  
  // Verify CreateSync and ClientWait for EGL_ANGLE_metal_shared_event_sync
  TEST_P(EGLSyncTestMetalSharedEvent, AngleMetalSharedEventSync_ClientWait)
  {
      ANGLE_SKIP_TEST_IF(!hasSyncMetalSharedEventExtension());
  
      id<MTLSharedEvent> sharedEvent = createMetalSharedEvent();
  
      EGLDisplay display      = getEGLWindow()->getDisplay();
      EGLAttrib syncAttribs[] = {EGL_SYNC_METAL_SHARED_EVENT_OBJECT_ANGLE,
                                 sharedEventAsAttrib(sharedEvent), EGL_NONE};
  
      // We can ClientWait on this
      EGLSync syncWithSharedEvent =
          eglCreateSync(display, EGL_SYNC_METAL_SHARED_EVENT_ANGLE, syncAttribs);
      EXPECT_NE(syncWithSharedEvent, EGL_NO_SYNC);
  
      // Create work to do
      glClearColor(0.0f, 1.0f, 1.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      glFlush();
  
      // Wait for the draw to complete
      glClear(GL_COLOR_BUFFER_BIT);
  
      // Don't wait forever to make sure the test terminates
      constexpr GLuint64 kTimeout = 1000000000;  // 1 second
      EGLAttrib value             = 0;
      EXPECT_EQ(EGL_CONDITION_SATISFIED, eglClientWaitSync(display, syncWithSharedEvent,
                                                           EGL_SYNC_FLUSH_COMMANDS_BIT, kTimeout));
      EXPECT_EGL_TRUE(eglGetSyncAttrib(display, syncWithSharedEvent, EGL_SYNC_STATUS, &value));
      EXPECT_EQ(value, EGL_SIGNALED);
  
      // Clean up created objects.
      EXPECT_EGL_TRUE(eglDestroySync(display, syncWithSharedEvent));
      sharedEvent = nil;
  }
  
  // Verify CreateSync and ClientWait for EGL_ANGLE_metal_shared_event_sync
  TEST_P(EGLSyncTestMetalSharedEvent, AngleMetalSharedEventSync_ClientWait_WithSignalValue)
  {
      ANGLE_SKIP_TEST_IF(!hasSyncMetalSharedEventExtension());
  
      id<MTLSharedEvent> sharedEvent = createMetalSharedEvent();
  
      constexpr uint64_t kSignalValue = 0xDEADBEEFCAFE;
      EGLDisplay display              = getEGLWindow()->getDisplay();
      EGLAttrib syncAttribs[]         = {EGL_SYNC_METAL_SHARED_EVENT_OBJECT_ANGLE,
                                         sharedEventAsAttrib(sharedEvent),
                                         EGL_SYNC_METAL_SHARED_EVENT_SIGNAL_VALUE_HI_ANGLE,
                                         Uint64HighPart(kSignalValue),
                                         EGL_SYNC_METAL_SHARED_EVENT_SIGNAL_VALUE_LO_ANGLE,
                                         Uint64LowPart(kSignalValue),
                                         EGL_NONE};
  
      // We can ClientWait on this
      EGLSync syncWithSharedEvent =
          eglCreateSync(display, EGL_SYNC_METAL_SHARED_EVENT_ANGLE, syncAttribs);
      EXPECT_NE(syncWithSharedEvent, EGL_NO_SYNC);
  
      // Create work to do
      glClearColor(0.0f, 1.0f, 1.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      glFlush();
  
      // Wait for the draw to complete
      glClear(GL_COLOR_BUFFER_BIT);
  
      // Don't wait forever to make sure the test terminates
      constexpr GLuint64 kTimeout = 1000000000;  // 1 second
      EGLAttrib value             = 0;
      EXPECT_EQ(EGL_CONDITION_SATISFIED, eglClientWaitSync(display, syncWithSharedEvent,
                                                           EGL_SYNC_FLUSH_COMMANDS_BIT, kTimeout));
      EXPECT_EGL_TRUE(eglGetSyncAttrib(display, syncWithSharedEvent, EGL_SYNC_STATUS, &value));
      EXPECT_EQ(value, EGL_SIGNALED);
      EXPECT_EQ(sharedEvent.signaledValue, kSignalValue);
  
      // Clean up created objects.
      EXPECT_EGL_TRUE(eglDestroySync(display, syncWithSharedEvent));
      sharedEvent = nil;
  }
  
  // Verify eglCopyMetalSharedEventANGLE for EGL_ANGLE_metal_shared_event_sync
  TEST_P(EGLSyncTestMetalSharedEvent, AngleMetalSharedEventSync_CopyMetalSharedEventANGLE)
  {
      ANGLE_SKIP_TEST_IF(!hasSyncMetalSharedEventExtension());
  
      EGLDisplay display = getEGLWindow()->getDisplay();
  
      // We can ClientWait on this
      EGLSync syncWithGeneratedEvent =
          eglCreateSyncKHR(display, EGL_SYNC_METAL_SHARED_EVENT_ANGLE, nullptr);
      EXPECT_NE(syncWithGeneratedEvent, EGL_NO_SYNC_KHR);
  
      id<MTLSharedEvent> sharedEvent =
          sharedEventFromVoidPtr(eglCopyMetalSharedEventANGLE(display, syncWithGeneratedEvent));
      EXPECT_EGL_SUCCESS();
      EXPECT_EQ([sharedEvent retainCount], 3ul);
  
      glFinish();
      EXPECT_EGL_TRUE(eglDestroySync(display, syncWithGeneratedEvent));
  
      // Clean up created objects.
      EXPECT_EQ([sharedEvent retainCount], 1ul);
      [sharedEvent release];
  }
  
  // Verify WaitSync with EGL_ANGLE_metal_shared_event_sync
  // Simulate passing shared events across processes by passing across Contexts.
  TEST_P(EGLSyncTestMetalSharedEvent, AngleMetalSharedEventSync_WaitSync)
  {
      ANGLE_SKIP_TEST_IF(!hasSyncMetalSharedEventExtension());
  
      id<MTLSharedEvent> sharedEvent = createMetalSharedEvent();
  
      EGLAttrib value    = 0;
      EGLDisplay display = getEGLWindow()->getDisplay();
      EGLSurface surface = getEGLWindow()->getSurface();
  
      /*- First Context ------------------------*/
  
      EGLAttrib syncAttribs[] = {EGL_SYNC_METAL_SHARED_EVENT_OBJECT_ANGLE,
                                 sharedEventAsAttrib(sharedEvent), EGL_NONE};
      // We can ClientWait on this
  
      EGLSync syncWithSharedEvent1 =
          eglCreateSync(display, EGL_SYNC_METAL_SHARED_EVENT_ANGLE, syncAttribs);
      EXPECT_NE(syncWithSharedEvent1, EGL_NO_SYNC);
      if (syncWithSharedEvent1 == EGL_NO_SYNC)
      {
          // Unable to continue with test.
          return;
      }
  
      // Create work to do
      glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      glFlush();
  
      /*- Second Context ------------------------*/
      EXPECT_EGL_TRUE(eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  
      EGLContext context2 = getEGLWindow()->createContext(EGL_NO_CONTEXT, nullptr);
      EXPECT_EGL_TRUE(eglMakeCurrent(display, surface, surface, context2));
  
      EGLSync syncWithSharedEvent2 =
          eglCreateSync(display, EGL_SYNC_METAL_SHARED_EVENT_ANGLE, syncAttribs);
      EXPECT_NE(syncWithSharedEvent2, EGL_NO_SYNC);
      if (syncWithSharedEvent2 == EGL_NO_SYNC)
      {
          // Unable to continue with test.
          return;
      }
  
      // Second draw waits for first to complete. May already be signaled - ignore error.
      if (eglWaitSync(display, syncWithSharedEvent2, 0) == EGL_TRUE)
      {
          // Create work to do
          glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
          glClear(GL_COLOR_BUFFER_BIT);
          glFlush();
      }
  
      // Wait for second draw to complete
      EXPECT_EQ(EGL_CONDITION_SATISFIED, eglClientWaitSync(display, syncWithSharedEvent2,
                                                           EGL_SYNC_FLUSH_COMMANDS_BIT, 1000000000));
      EXPECT_EGL_TRUE(eglGetSyncAttrib(display, syncWithSharedEvent2, EGL_SYNC_STATUS, &value));
      EXPECT_EQ(value, EGL_SIGNALED);
  
      // Reset to default context and surface.
      EXPECT_EGL_TRUE(eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
      EXPECT_EGL_TRUE(eglMakeCurrent(display, surface, surface, getEGLWindow()->getContext()));
  
      // Clean up created objects.
      EXPECT_EGL_TRUE(eglDestroySync(display, syncWithSharedEvent2));
      EXPECT_EGL_TRUE(eglDestroyContext(display, context2));
  
      // Wait for first draw to complete
      EXPECT_EQ(EGL_CONDITION_SATISFIED, eglClientWaitSync(display, syncWithSharedEvent1,
                                                           EGL_SYNC_FLUSH_COMMANDS_BIT, 1000000000));
      EXPECT_EGL_TRUE(eglGetSyncAttrib(display, syncWithSharedEvent1, EGL_SYNC_STATUS, &value));
      EXPECT_EQ(value, EGL_SIGNALED);
  
      // Clean up created objects.
      EXPECT_EGL_TRUE(eglDestroySync(display, syncWithSharedEvent1));
      sharedEvent = nil;
  }
  
  ANGLE_INSTANTIATE_TEST(EGLSyncTestMetalSharedEvent, ES2_METAL(), ES3_METAL());
  // This test suite is not instantiated on non-Metal backends and OSes.
  GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EGLSyncTestMetalSharedEvent);
  

Download