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

• Show log

  Commit

• Hash : e755a537
  Author :
  Date : 2019-04-10T09:58:21
  

  Vulkan: Add a new garbage type gated by fences.
  
  This allows Vulkan EGL objects such as EGL Syncs and EGL Images to give their
  garbage to the renderer before destroying.
  
  BUG=angleproject:2464
  
  Change-Id: I59b8e1080e4292bd0856e59a928750c7e77a372e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1562522
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

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

• //
  // 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.cpp:
  //    Implements the class methods for SyncVk.
  //
  
  #include "libANGLE/renderer/vulkan/SyncVk.h"
  
  #include "common/debug.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/Display.h"
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  #include "libANGLE/renderer/vulkan/DisplayVk.h"
  
  namespace rx
  {
  FenceSyncVk::FenceSyncVk() {}
  
  FenceSyncVk::~FenceSyncVk() {}
  
  void FenceSyncVk::onDestroy(RendererVk *renderer)
  {
      if (mEvent.valid())
      {
          renderer->releaseObject(renderer->getCurrentQueueSerial(), &mEvent);
      }
  
      mFence.reset(renderer->getDevice());
  }
  
  void FenceSyncVk::onDestroy(DisplayVk *display)
  {
      std::vector<vk::GarbageObjectBase> garbage;
      mEvent.dumpResources(&garbage);
  
      display->getRenderer()->addGarbage(std::move(mFence), std::move(garbage));
  }
  
  angle::Result FenceSyncVk::initialize(ContextVk *contextVk)
  {
      ASSERT(!mEvent.valid());
  
      RendererVk *renderer = contextVk->getRenderer();
      VkDevice device      = renderer->getDevice();
  
      VkEventCreateInfo eventCreateInfo = {};
      eventCreateInfo.sType             = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
      eventCreateInfo.flags             = 0;
  
      vk::Scoped<vk::Event> event(device);
      ANGLE_VK_TRY(contextVk, event.get().init(device, eventCreateInfo));
  
      ANGLE_TRY(renderer->getSubmitFence(contextVk, &mFence));
  
      mEvent        = event.release();
  
      renderer->getCommandGraph()->setFenceSync(mEvent);
      return angle::Result::Continue;
  }
  
  angle::Result FenceSyncVk::clientWait(vk::Context *context,
                                        ContextVk *contextVk,
                                        bool flushCommands,
                                        uint64_t timeout,
                                        VkResult *outResult)
  {
      RendererVk *renderer = context->getRenderer();
  
      // If the event is already set, don't wait
      bool alreadySignaled = false;
      ANGLE_TRY(getStatus(context, &alreadySignaled));
      if (alreadySignaled)
      {
          *outResult = VK_EVENT_SET;
          return angle::Result::Continue;
      }
  
      // If timeout is zero, there's no need to wait, so return timeout already.
      if (timeout == 0)
      {
          *outResult = VK_TIMEOUT;
          return angle::Result::Continue;
      }
  
      if (flushCommands && contextVk)
      {
          ANGLE_TRY(contextVk->flushImpl());
      }
  
      // Wait on the fence that's expected to be signaled on the first vkQueueSubmit after
      // `initialize` was called.
      VkResult status = mFence.get().wait(renderer->getDevice(), timeout);
  
      // Check for errors, but don't consider timeout as such.
      if (status != VK_TIMEOUT)
      {
          ANGLE_VK_TRY(context, status);
      }
  
      *outResult = status;
      return angle::Result::Continue;
  }
  
  angle::Result FenceSyncVk::serverWait(vk::Context *context, ContextVk *contextVk)
  {
      context->getRenderer()->getCommandGraph()->waitFenceSync(mEvent);
      return angle::Result::Continue;
  }
  
  angle::Result FenceSyncVk::getStatus(vk::Context *context, bool *signaled)
  {
      VkResult result = mEvent.getStatus(context->getRenderer()->getDevice());
      if (result != VK_EVENT_SET && result != VK_EVENT_RESET)
      {
          ANGLE_VK_TRY(context, result);
      }
      *signaled = result == VK_EVENT_SET;
      return angle::Result::Continue;
  }
  
  SyncVk::SyncVk() : SyncImpl() {}
  
  SyncVk::~SyncVk() {}
  
  void SyncVk::onDestroy(const gl::Context *context)
  {
      mFenceSync.onDestroy(vk::GetImpl(context)->getRenderer());
  }
  
  angle::Result SyncVk::set(const gl::Context *context, GLenum condition, GLbitfield flags)
  {
      ASSERT(condition == GL_SYNC_GPU_COMMANDS_COMPLETE);
      ASSERT(flags == 0);
  
      return mFenceSync.initialize(vk::GetImpl(context));
  }
  
  angle::Result SyncVk::clientWait(const gl::Context *context,
                                   GLbitfield flags,
                                   GLuint64 timeout,
                                   GLenum *outResult)
  {
      ContextVk *contextVk = vk::GetImpl(context);
  
      ASSERT((flags & ~GL_SYNC_FLUSH_COMMANDS_BIT) == 0);
  
      bool flush = (flags & GL_SYNC_FLUSH_COMMANDS_BIT) != 0;
      VkResult result;
  
      ANGLE_TRY(mFenceSync.clientWait(contextVk, contextVk, flush, static_cast<uint64_t>(timeout),
                                      &result));
  
      switch (result)
      {
          case VK_EVENT_SET:
              *outResult = GL_ALREADY_SIGNALED;
              return angle::Result::Continue;
  
          case VK_SUCCESS:
              *outResult = GL_CONDITION_SATISFIED;
              return angle::Result::Continue;
  
          case VK_TIMEOUT:
              *outResult = GL_TIMEOUT_EXPIRED;
              return angle::Result::Incomplete;
  
          default:
              UNREACHABLE();
              *outResult = GL_WAIT_FAILED;
              return angle::Result::Stop;
      }
  }
  
  angle::Result SyncVk::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
  {
      ASSERT(flags == 0);
      ASSERT(timeout == GL_TIMEOUT_IGNORED);
  
      ContextVk *contextVk = vk::GetImpl(context);
      return mFenceSync.serverWait(contextVk, contextVk);
  }
  
  angle::Result SyncVk::getStatus(const gl::Context *context, GLint *outResult)
  {
      bool signaled = false;
      ANGLE_TRY(mFenceSync.getStatus(vk::GetImpl(context), &signaled));
  
      *outResult = signaled ? GL_SIGNALED : GL_UNSIGNALED;
      return angle::Result::Continue;
  }
  
  EGLSyncVk::EGLSyncVk(const egl::AttributeMap &attribs) : EGLSyncImpl()
  {
      ASSERT(attribs.isEmpty());
  }
  
  EGLSyncVk::~EGLSyncVk() {}
  
  void EGLSyncVk::onDestroy(const egl::Display *display)
  {
      mFenceSync.onDestroy(vk::GetImpl(display)->getRenderer());
  }
  
  egl::Error EGLSyncVk::initialize(const egl::Display *display,
                                   const gl::Context *context,
                                   EGLenum type)
  {
      ASSERT(type == EGL_SYNC_FENCE_KHR);
      ASSERT(context != nullptr);
  
      if (mFenceSync.initialize(vk::GetImpl(context)) == angle::Result::Stop)
      {
          return egl::Error(EGL_BAD_ALLOC, "eglCreateSyncKHR failed to create sync object");
      }
  
      return egl::NoError();
  }
  
  egl::Error EGLSyncVk::clientWait(const egl::Display *display,
                                   const gl::Context *context,
                                   EGLint flags,
                                   EGLTime timeout,
                                   EGLint *outResult)
  {
      ASSERT((flags & ~EGL_SYNC_FLUSH_COMMANDS_BIT_KHR) == 0);
  
      bool flush = (flags & EGL_SYNC_FLUSH_COMMANDS_BIT_KHR) != 0;
      VkResult result;
  
      ContextVk *contextVk = context ? vk::GetImpl(context) : nullptr;
      if (mFenceSync.clientWait(vk::GetImpl(display), contextVk, flush,
                                static_cast<uint64_t>(timeout), &result) == angle::Result::Stop)
      {
          return egl::Error(EGL_BAD_ALLOC);
      }
  
      switch (result)
      {
          case VK_EVENT_SET:
              // fall through.  EGL doesn't differentiate between event being already set, or set
              // before timeout.
          case VK_SUCCESS:
              *outResult = EGL_CONDITION_SATISFIED_KHR;
              return egl::NoError();
  
          case VK_TIMEOUT:
              *outResult = EGL_TIMEOUT_EXPIRED_KHR;
              return egl::NoError();
  
          default:
              UNREACHABLE();
              *outResult = EGL_FALSE;
              return egl::Error(EGL_BAD_ALLOC);
      }
  }
  
  egl::Error EGLSyncVk::serverWait(const egl::Display *display,
                                   const gl::Context *context,
                                   EGLint flags)
  {
      ASSERT(flags == 0);
      ContextVk *contextVk = context ? vk::GetImpl(context) : nullptr;
      if (mFenceSync.serverWait(vk::GetImpl(display), contextVk) == angle::Result::Stop)
      {
          return egl::Error(EGL_BAD_ALLOC);
      }
      return egl::NoError();
  }
  
  egl::Error EGLSyncVk::getStatus(const egl::Display *display, EGLint *outStatus)
  {
      bool signaled = false;
      if (mFenceSync.getStatus(vk::GetImpl(display), &signaled) == angle::Result::Stop)
      {
          return egl::Error(EGL_BAD_ALLOC);
      }
  
      *outStatus = signaled ? EGL_SIGNALED_KHR : EGL_UNSIGNALED_KHR;
      return egl::NoError();
  }
  
  }  // namespace rx
  

Download