kc3-lang/angle/src/tests/test_utils/VulkanHelper.h

• Show log

  Commit

• Hash : bbc0d702
  Author :
  Date : 2024-12-27T07:44:01
  

  Vulkan: Add entry points to lock the Vulkan queue
  
  ... which can be retrieved via EGL_ANGLE_device_vulkan.  Otherwise the
  application is unable to use the VkQueue that is retrieved out of ANGLE
  from other threads (such as Chromium's DrDC feature).
  
  Bug: chromium:380295059
  Change-Id: Ife80f54440777486f72fc61697a68fb0c2b2d0f7
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6116046
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/tests/test_utils/VulkanHelper.h

• //
  // Copyright 2019 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.
  //
  // VulkanHelper.h : Helper for vulkan.
  
  #ifndef ANGLE_TESTS_TESTUTILS_VULKANHELPER_H_
  #define ANGLE_TESTS_TESTUTILS_VULKANHELPER_H_
  
  #include <mutex>
  
  #include "common/angleutils.h"
  #include "common/vulkan/vk_headers.h"
  #include "test_utils/ANGLETest.h"
  #include "vulkan/vulkan_fuchsia_ext.h"
  
  namespace angle
  {
  class VulkanQueueMutex
  {
    public:
      void init(EGLDisplay dpy);
  
      void lock();
      void unlock();
  
    private:
      EGLDisplay display;
  };
  
  class VulkanHelper
  {
    public:
      VulkanHelper();
      ~VulkanHelper();
  
      void initialize(bool useSwiftshader, bool enableValidationLayers);
      void initializeFromANGLE();
  
      VkInstance getInstance() const { return mInstance; }
      VkPhysicalDevice getPhysicalDevice() const { return mPhysicalDevice; }
      VkDevice getDevice() const { return mDevice; }
      VkQueue getGraphicsQueue() const { return mGraphicsQueue; }
      std::unique_lock<VulkanQueueMutex> getGraphicsQueueLock()
      {
          if (mInitializedFromANGLE)
          {
              return std::unique_lock<VulkanQueueMutex>(mGraphicsQueueMutex);
          }
          return std::unique_lock<VulkanQueueMutex>();
      }
  
      VkResult createImage2D(VkFormat format,
                             VkImageCreateFlags createFlags,
                             VkImageUsageFlags usageFlags,
                             VkExtent3D extent,
                             VkImage *imageOut,
                             VkDeviceMemory *deviceMemoryOut,
                             VkDeviceSize *deviceMemorySizeOut,
                             VkImageCreateInfo *imageCreateInfoOut);
      bool canCreateImageExternal(VkFormat format,
                                  VkImageType type,
                                  VkImageTiling tiling,
                                  VkImageCreateFlags createFlags,
                                  VkImageUsageFlags usageFlags,
                                  VkExternalMemoryHandleTypeFlagBits handleType) const;
      VkResult createImage2DExternal(VkFormat format,
                                     VkImageCreateFlags createFlags,
                                     VkImageUsageFlags usageFlags,
                                     const void *imageCreateInfoPNext,
                                     VkExtent3D extent,
                                     VkExternalMemoryHandleTypeFlags handleTypes,
                                     VkImage *imageOut,
                                     VkDeviceMemory *deviceMemoryOut,
                                     VkDeviceSize *deviceMemorySizeOut);
  
      // VK_KHR_external_memory_fd
      bool canCreateImageOpaqueFd(VkFormat format,
                                  VkImageType type,
                                  VkImageTiling tiling,
                                  VkImageCreateFlags createFlags,
                                  VkImageUsageFlags usageFlags) const;
      VkResult createImage2DOpaqueFd(VkFormat format,
                                     VkImageCreateFlags createFlags,
                                     VkImageUsageFlags usageFlags,
                                     const void *imageCreateInfoPNext,
                                     VkExtent3D extent,
                                     VkImage *imageOut,
                                     VkDeviceMemory *deviceMemoryOut,
                                     VkDeviceSize *deviceMemorySizeOut);
      VkResult exportMemoryOpaqueFd(VkDeviceMemory deviceMemory, int *fd);
  
      // VK_FUCHSIA_external_memory
      bool canCreateImageZirconVmo(VkFormat format,
                                   VkImageType type,
                                   VkImageTiling tiling,
                                   VkImageCreateFlags createFlags,
                                   VkImageUsageFlags usageFlags) const;
      VkResult createImage2DZirconVmo(VkFormat format,
                                      VkImageCreateFlags createFlags,
                                      VkImageUsageFlags usageFlags,
                                      const void *imageCreateInfoPNext,
                                      VkExtent3D extent,
                                      VkImage *imageOut,
                                      VkDeviceMemory *deviceMemoryOut,
                                      VkDeviceSize *deviceMemorySizeOut);
      VkResult exportMemoryZirconVmo(VkDeviceMemory deviceMemory, zx_handle_t *vmo);
  
      // VK_KHR_external_semaphore_fd
      bool canCreateSemaphoreOpaqueFd() const;
      VkResult createSemaphoreOpaqueFd(VkSemaphore *semaphore);
      VkResult exportSemaphoreOpaqueFd(VkSemaphore semaphore, int *fd);
  
      // VK_FUCHSIA_external_semaphore
      bool canCreateSemaphoreZirconEvent() const;
      VkResult createSemaphoreZirconEvent(VkSemaphore *semaphore);
      VkResult exportSemaphoreZirconEvent(VkSemaphore semaphore, zx_handle_t *event);
  
      // Performs a queue ownership transfer to VK_QUEUE_FAMILY_EXTERNAL on an
      // image owned by our instance. The current image layout must be |oldLayout|
      // and will be in |newLayout| after the memory barrier. |semaphore|
      // will be signaled upon completion of the release operation.
      void releaseImageAndSignalSemaphore(VkImage image,
                                          VkImageLayout oldLayout,
                                          VkImageLayout newLayout,
                                          VkSemaphore semaphore);
      // Just signal the given semaphore
      void signalSemaphore(VkSemaphore semaphore);
  
      // Performs a queue ownership transfer from VK_QUEUE_FAMILY_EXTERNAL on an
      // image owned by an external instance. The current image layout must be
      // |oldLayout| and will be in |newLayout| after the memory barrier. The
      // barrier will wait for |semaphore|.
      void waitSemaphoreAndAcquireImage(VkImage image,
                                        VkImageLayout oldLayout,
                                        VkImageLayout newLayout,
                                        VkSemaphore semaphore);
  
      // Writes pixels into an image. Currently only VK_FORMAT_R8G8B8A8_UNORM
      // and VK_FORMAT_B8G8R8A8_UNORM formats are supported.
      void writePixels(VkImage dstImage,
                       VkImageLayout imageLayout,
                       VkFormat imageFormat,
                       VkOffset3D imageOffset,
                       VkExtent3D imageExtent,
                       const void *pixels,
                       size_t pixelsSize);
  
      // Copies pixels out of an image. Currently only VK_FORMAT_R8G8B8A8_UNORM
      // and VK_FORMAT_B8G8R8A8_UNORM formats are supported.
      void readPixels(VkImage srcImage,
                      VkImageLayout srcImageLayout,
                      VkFormat srcImageFormat,
                      VkOffset3D imageOffset,
                      VkExtent3D imageExtent,
                      void *pixels,
                      size_t pixelsSize);
  
    private:
      bool mInitializedFromANGLE       = false;
      VkInstance mInstance             = VK_NULL_HANDLE;
      VkPhysicalDevice mPhysicalDevice = VK_NULL_HANDLE;
      VkDevice mDevice                 = VK_NULL_HANDLE;
      VkQueue mGraphicsQueue           = VK_NULL_HANDLE;
      VkCommandPool mCommandPool       = VK_NULL_HANDLE;
      VulkanQueueMutex mGraphicsQueueMutex;
  
      VkPhysicalDeviceMemoryProperties mMemoryProperties = {};
  
      uint32_t mGraphicsQueueFamilyIndex = UINT32_MAX;
  
      bool mHasExternalMemoryFd         = false;
      bool mHasExternalMemoryFuchsia    = false;
      bool mHasExternalSemaphoreFd      = false;
      bool mHasExternalSemaphoreFuchsia = false;
      PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 =
          nullptr;
      PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR       = nullptr;
      PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = nullptr;
      ANGLE_MAYBE_UNUSED_PRIVATE_FIELD PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
          vkGetPhysicalDeviceExternalSemaphorePropertiesKHR                   = nullptr;
      PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA       = nullptr;
      PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = nullptr;
  };
  
  }  // namespace angle
  
  #endif  // ANGLE_TESTS_TESTUTILS_VULKANHELPER_H_
  

Download