kc3-lang/angle/src/libANGLE/renderer/vulkan/SyncVk.h

• Show log

  Commit

• Hash : 3dfc8004
  Author :
  Date : 2022-06-08T14:24:48
  

  Vulkan: Optimize sync followed by swap
  
  Previously, inserting a sync object immediately caused a submission.
  That was done in
  https://chromium-review.googlesource.com/c/angle/angle/+/3200274 to be
  able to wait until the sync object is signaled without having to wait
  for whatever is recorded after it until a flush naturally happens.
  
  Some applications issue a glFenceSync right before eglSwapBuffers.  The
  submission incurred by glFenceSync disallowed the optimizations that
  eglSwapBuffers would have done, leading to performance degradations.
  This could have been avoided if glFenceSync was issued right after
  eglSwapBuffers, but that's not the case with a number of applications.
  
  In this change, when a fence is inserted:
  
  - For EGL sync objects, a submission is issued regardless
  - For GL sync objects, a submission is issued if there is no render pass
    open
  - For GL sync objects, the submission is deferred if there is an open
    render pass.  This is done by marking the render pass closed, and
    flagging the context as having a deferred flash.
  
  If the context that issued the fence sync issues another draw call, the
  render pass is naturally closed and the submission is performed.
  
  If the context that issued the fence sync causes a submission, it would
  have a chance to modify the render pass before doing so.  For example,
  it could apply swapchain optimizations before swapping, or add a resolve
  attachment for blit.
  
  If the context that issued the fence sync doesn't cause a submission
  before another context tries to access it (get status, wait, etc), the
  other context will flush its render pass and cause a submission on its
  behalf.  This is possible because the deferral of submission is done
  only for GL sync objects, and those are only accessible by other
  contexts in the same share group.
  
  Bug: angleproject:7379
  Change-Id: I3dd1c1bfd575206d730dd9ee2e33ba2254318521
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3695520
  Reviewed-by: Charlie Lao <cclao@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/SyncVk.h

• //
  // Copyright 2016 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.
  //
  // SyncVk:
  //    Defines the class interface for SyncVk, implementing SyncImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_FENCESYNCVK_H_
  #define LIBANGLE_RENDERER_VULKAN_FENCESYNCVK_H_
  
  #include "libANGLE/renderer/EGLSyncImpl.h"
  #include "libANGLE/renderer/SyncImpl.h"
  #include "libANGLE/renderer/vulkan/ResourceVk.h"
  
  namespace egl
  {
  class AttributeMap;
  }
  
  namespace rx
  {
  namespace vk
  {
  
  // Represents an invalid native fence FD.
  constexpr int kInvalidFenceFd = EGL_NO_NATIVE_FENCE_FD_ANDROID;
  
  // Implementation of fence types - glFenceSync, and EGLSync(EGL_SYNC_FENCE_KHR).
  // The behaviors of SyncVk and EGLFenceSyncVk as fence syncs are currently
  // identical for the Vulkan backend, and this class implements both interfaces.
  class SyncHelper : public vk::Resource
  {
    public:
      SyncHelper();
      ~SyncHelper() override;
  
      virtual void releaseToRenderer(RendererVk *renderer);
  
      virtual angle::Result initialize(ContextVk *contextVk, bool isEGLSyncObject);
      virtual angle::Result clientWait(Context *context,
                                       ContextVk *contextVk,
                                       bool flushCommands,
                                       uint64_t timeout,
                                       VkResult *outResult);
      virtual angle::Result serverWait(ContextVk *contextVk);
      virtual angle::Result getStatus(Context *context, ContextVk *contextVk, bool *signaled);
      virtual angle::Result dupNativeFenceFD(Context *context, int *fdOut) const
      {
          return angle::Result::Stop;
      }
  
    private:
      angle::Result submitSyncIfDeferred(ContextVk *contextVk, RenderPassClosureReason reason);
  };
  
  // Implementation of sync types: EGLSync(EGL_SYNC_ANDROID_NATIVE_FENCE_ANDROID).
  class SyncHelperNativeFence : public SyncHelper
  {
    public:
      SyncHelperNativeFence();
      ~SyncHelperNativeFence() override;
  
      void releaseToRenderer(RendererVk *renderer) override;
  
      angle::Result initializeWithFd(ContextVk *contextVk, int inFd);
      angle::Result clientWait(Context *context,
                               ContextVk *contextVk,
                               bool flushCommands,
                               uint64_t timeout,
                               VkResult *outResult) override;
      angle::Result serverWait(ContextVk *contextVk) override;
      angle::Result getStatus(Context *context, ContextVk *contextVk, bool *signaled) override;
      angle::Result dupNativeFenceFD(Context *context, int *fdOut) const override;
  
    private:
      vk::Fence mFenceWithFd;
      int mNativeFenceFd;
  };
  
  }  // namespace vk
  
  // Implementor for glFenceSync.
  class SyncVk final : public SyncImpl
  {
    public:
      SyncVk();
      ~SyncVk() 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:
      vk::SyncHelper mSyncHelper;
  };
  
  // Implementor for EGLSync.
  class EGLSyncVk final : public EGLSyncImpl
  {
    public:
      EGLSyncVk(const egl::AttributeMap &attribs);
      ~EGLSyncVk() override;
  
      void onDestroy(const egl::Display *display) override;
  
      egl::Error initialize(const egl::Display *display,
                            const gl::Context *context,
                            EGLenum type) 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 dupNativeFenceFD(const egl::Display *display, EGLint *fdOut) const override;
  
    private:
      EGLenum mType;
      vk::SyncHelper *mSyncHelper;  // SyncHelper or SyncHelperNativeFence decided at run-time.
      const egl::AttributeMap &mAttribs;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_FENCESYNCVK_H_
  

Download