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

• Show log

  Commit

• Hash : f10bf6bf
  Author :
  Date : 2019-09-26T10:27:18
  

  Vulkan: Implement multi-threaded GL.
  
  The main component of this change is to make vk::BufferHelper,
  vk::ImageHelper and vk::SyncHelper use a common path. We introduce a
  new "vk::SharedGarbage" helper class that stores small lists of garbage
  from individual objects like an ImageHelper or BufferHelper. The
  SharedGarbage is stored in the RendererVk with the ResourceUse of the
  helper object. The ResourceUse tells RendererVk when it is safe to
  destroy the GarbageObjects.
  
  New "onGraphAccess" commands are added in a few places to enable the
  common garbage collection path. A couple Context-only resources like
  default attributes now are referenced where they were not before.
  
  Also reorganizes some functions so we can add a few helpful ASSERTs
  to our graph dependencies. Added "updateCurrentAccessNodes" for this.
  
  Also adds a "RendererScoped" helper to replace many uses of
  "ContextScoped".
  
  The multithreading EGL tests mostly pass but have some remaining
  flakiness so cannot yet be enabled.
  
  Bug: angleproject:2464
  Change-Id: Ia3e3ae8848d731abf3f21ebe04c33e381e130be0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1808444
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@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/CommandGraph.h"
  
  namespace egl
  {
  class AttributeMap;
  }
  
  namespace rx
  {
  namespace vk
  {
  // The behaviors of SyncImpl and EGLSyncImpl as fence syncs (only supported type) are currently
  // identical for the Vulkan backend, and this class implements both interfaces.
  class SyncHelper
  {
    public:
      SyncHelper();
      ~SyncHelper();
  
      void releaseToRenderer(RendererVk *renderer);
  
      angle::Result initialize(ContextVk *contextVk);
      angle::Result clientWait(Context *context,
                               ContextVk *contextVk,
                               bool flushCommands,
                               uint64_t timeout,
                               VkResult *outResult);
      void serverWait(ContextVk *contextVk);
      angle::Result getStatus(Context *context, bool *signaled);
  
    private:
      // The vkEvent that's signaled on `init` and can be waited on in `serverWait`, or queried with
      // `getStatus`.
      Event mEvent;
      // The fence is signaled once the CB including the `init` signal is executed.
      // `clientWait` waits on this fence.
      Shared<Fence> mFence;
  
      SharedResourceUse mUse;
  };
  }  // namespace vk
  
  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 mFenceSync;
  };
  
  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 *result) const override;
  
    private:
      vk::SyncHelper mFenceSync;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_FENCESYNCVK_H_
  

Download