kc3-lang/angle/src/libANGLE/renderer/metal/SyncMtl.h

• Show log

  Commit

• Hash : 774bca93
  Author :
  Date : 2025-10-08T18:41:13
  

  [metal] Add commands scheduled sync object
  
  We need a thread-safe way to wait for ANGLE Metal command buffers to be
  scheduled for IOSurface synchronization with DrDC + Graphite on Mac.
  The existing eglWaitUntilWorkScheduledANGLE API isn't thread-safe as it
  reaches into ContextMtl innards to flush the command buffer.
  
  This CL adds the EGL_ANGLE_metal_commands_scheduled_sync extension which
  introduces a EGL_SYNC_METAL_COMMANDS_SCHEDULED_ANGLE sync object type.
  This sync object is signaled when pending Metal commands are scheduled
  to run on the GPU (MTLCommandBufferStatusScheduled). These sync objects
  are thread-safe - eglClientWaitSync() can be called on any thread even
  without a current context which is needed for DrDC + Graphite on Mac.
  
  Bug: chromium:444702048
  Change-Id: Ia13b352385a6fefaa026526ef74f6e596a6a6964
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/7027996
  Auto-Submit: Sunny Sachanandani <sunnyps@chromium.org>
  Reviewed-by: Quyen Le <lehoangquyen@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Sunny Sachanandani <sunnyps@chromium.org>
  

Download

• src/libANGLE/renderer/metal/SyncMtl.h

• //
  // Copyright (c) 2020 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.
  //
  // SyncMtl:
  //    Defines the class interface for SyncMtl, implementing SyncImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_METAL_SYNCMTL_H_
  #define LIBANGLE_RENDERER_METAL_SYNCMTL_H_
  
  #include <optional>
  
  #include "libANGLE/renderer/EGLSyncImpl.h"
  #include "libANGLE/renderer/FenceNVImpl.h"
  #include "libANGLE/renderer/SyncImpl.h"
  #include "libANGLE/renderer/metal/mtl_common.h"
  
  namespace egl
  {
  class AttributeMap;
  }
  
  namespace rx
  {
  
  class ContextMtl;
  
  namespace mtl
  {
  class SyncImpl;
  }  // namespace mtl
  
  class FenceNVMtl : public FenceNVImpl
  {
    public:
      FenceNVMtl();
      ~FenceNVMtl() override;
      void onDestroy(const gl::Context *context) override;
      angle::Result set(const gl::Context *context, GLenum condition) override;
      angle::Result test(const gl::Context *context, GLboolean *outFinished) override;
      angle::Result finish(const gl::Context *context) override;
  
    private:
      std::unique_ptr<mtl::SyncImpl> mSync;
  };
  
  class SyncMtl : public SyncImpl
  {
    public:
      SyncMtl();
      ~SyncMtl() override;
  
      void onDestroy(const gl::Context *context) override;
  
      angle::Result set(const gl::Context *context, GLenum condition, GLbitfield flags) override;
      angle::Result clientWait(const gl::Context *context,
                               GLbitfield flags,
                               GLuint64 timeout,
                               GLenum *outResult) override;
      angle::Result serverWait(const gl::Context *context,
                               GLbitfield flags,
                               GLuint64 timeout) override;
      angle::Result getStatus(const gl::Context *context, GLint *outResult) override;
  
    private:
      std::unique_ptr<mtl::SyncImpl> mSync;
  };
  
  class EGLSyncMtl final : public EGLSyncImpl
  {
    public:
      EGLSyncMtl();
      ~EGLSyncMtl() override;
  
      void onDestroy(const egl::Display *display) override;
  
      egl::Error initialize(const egl::Display *display,
                            const gl::Context *context,
                            EGLenum type,
                            const egl::AttributeMap &attribs) override;
      egl::Error clientWait(const egl::Display *display,
                            const gl::Context *context,
                            EGLint flags,
                            EGLTime timeout,
                            EGLint *outResult) override;
      egl::Error serverWait(const egl::Display *display,
                            const gl::Context *context,
                            EGLint flags) override;
      egl::Error getStatus(const egl::Display *display, EGLint *outStatus) override;
  
      egl::Error copyMetalSharedEventANGLE(const egl::Display *display, void **result) const override;
      egl::Error dupNativeFenceFD(const egl::Display *display, EGLint *result) const override;
  
    private:
      angle::ObjCPtr<id<MTLSharedEvent>> mSharedEvent;
      EGLenum mType = EGL_NONE;
      std::unique_ptr<mtl::SyncImpl> mSync;
  };
  
  }  // namespace rx
  
  #endif
  

Download