| // Copyright 2021 The Dawn Authors |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "tests/white_box/VulkanImageWrappingTests.h" |
| |
| #include "dawn_native/vulkan/DeviceVk.h" |
| #include "dawn_native/vulkan/FencedDeleter.h" |
| #include "dawn_native/vulkan/ResourceMemoryAllocatorVk.h" |
| |
| #include <gtest/gtest.h> |
| #include <unistd.h> |
| |
| namespace dawn::native::vulkan { |
| |
| class ExternalSemaphoreOpaqueFD : public VulkanImageWrappingTestBackend::ExternalSemaphore { |
| public: |
| ExternalSemaphoreOpaqueFD(int handle) : mHandle(handle) { |
| } |
| ~ExternalSemaphoreOpaqueFD() override { |
| if (mHandle != -1) { |
| close(mHandle); |
| } |
| } |
| int AcquireHandle() { |
| int handle = mHandle; |
| mHandle = -1; |
| return handle; |
| } |
| |
| private: |
| int mHandle = -1; |
| }; |
| |
| class ExternalTextureOpaqueFD : public VulkanImageWrappingTestBackend::ExternalTexture { |
| public: |
| ExternalTextureOpaqueFD(dawn::native::vulkan::Device* device, |
| int fd, |
| VkDeviceMemory allocation, |
| VkImage handle, |
| VkDeviceSize allocationSize, |
| uint32_t memoryTypeIndex) |
| : mDevice(device), |
| mFd(fd), |
| mAllocation(allocation), |
| mHandle(handle), |
| allocationSize(allocationSize), |
| memoryTypeIndex(memoryTypeIndex) { |
| } |
| |
| ~ExternalTextureOpaqueFD() override { |
| if (mFd != -1) { |
| close(mFd); |
| } |
| if (mAllocation != VK_NULL_HANDLE) { |
| mDevice->GetFencedDeleter()->DeleteWhenUnused(mAllocation); |
| } |
| if (mHandle != VK_NULL_HANDLE) { |
| mDevice->GetFencedDeleter()->DeleteWhenUnused(mHandle); |
| } |
| } |
| |
| int Dup() const { |
| return dup(mFd); |
| } |
| |
| private: |
| dawn::native::vulkan::Device* mDevice; |
| int mFd = -1; |
| VkDeviceMemory mAllocation = VK_NULL_HANDLE; |
| VkImage mHandle = VK_NULL_HANDLE; |
| |
| public: |
| const VkDeviceSize allocationSize; |
| const uint32_t memoryTypeIndex; |
| }; |
| |
| class VulkanImageWrappingTestBackendOpaqueFD : public VulkanImageWrappingTestBackend { |
| public: |
| VulkanImageWrappingTestBackendOpaqueFD(const wgpu::Device& device) : mDevice(device) { |
| mDeviceVk = dawn::native::vulkan::ToBackend(dawn::native::FromAPI(device.Get())); |
| } |
| |
| std::unique_ptr<ExternalTexture> CreateTexture(uint32_t width, |
| uint32_t height, |
| wgpu::TextureFormat format, |
| wgpu::TextureUsage usage) override { |
| EXPECT_EQ(format, wgpu::TextureFormat::RGBA8Unorm); |
| VkFormat vulkanFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| |
| VkImage handle; |
| ::VkResult result = CreateImage(mDeviceVk, width, height, vulkanFormat, &handle); |
| EXPECT_EQ(result, VK_SUCCESS) << "Failed to create external image"; |
| |
| VkDeviceMemory allocation; |
| VkDeviceSize allocationSize; |
| uint32_t memoryTypeIndex; |
| ::VkResult resultBool = |
| AllocateMemory(mDeviceVk, handle, &allocation, &allocationSize, &memoryTypeIndex); |
| EXPECT_EQ(resultBool, VK_SUCCESS) << "Failed to allocate external memory"; |
| |
| result = BindMemory(mDeviceVk, handle, allocation); |
| EXPECT_EQ(result, VK_SUCCESS) << "Failed to bind image memory"; |
| |
| int fd = GetMemoryFd(mDeviceVk, allocation); |
| |
| return std::make_unique<ExternalTextureOpaqueFD>(mDeviceVk, fd, allocation, handle, |
| allocationSize, memoryTypeIndex); |
| } |
| |
| wgpu::Texture WrapImage( |
| const wgpu::Device& device, |
| const ExternalTexture* texture, |
| const ExternalImageDescriptorVkForTesting& descriptor, |
| std::vector<std::unique_ptr<ExternalSemaphore>> semaphores) override { |
| const ExternalTextureOpaqueFD* textureOpaqueFD = |
| static_cast<const ExternalTextureOpaqueFD*>(texture); |
| std::vector<int> waitFDs; |
| for (auto& semaphore : semaphores) { |
| waitFDs.push_back( |
| static_cast<ExternalSemaphoreOpaqueFD*>(semaphore.get())->AcquireHandle()); |
| } |
| |
| ExternalImageDescriptorOpaqueFD descriptorOpaqueFD; |
| *static_cast<ExternalImageDescriptorVk*>(&descriptorOpaqueFD) = descriptor; |
| descriptorOpaqueFD.memoryFD = textureOpaqueFD->Dup(); |
| descriptorOpaqueFD.allocationSize = textureOpaqueFD->allocationSize; |
| descriptorOpaqueFD.memoryTypeIndex = textureOpaqueFD->memoryTypeIndex; |
| descriptorOpaqueFD.waitFDs = std::move(waitFDs); |
| |
| return dawn::native::vulkan::WrapVulkanImage(device.Get(), &descriptorOpaqueFD); |
| } |
| |
| bool ExportImage(const wgpu::Texture& texture, |
| VkImageLayout layout, |
| ExternalImageExportInfoVkForTesting* exportInfo) override { |
| ExternalImageExportInfoOpaqueFD infoOpaqueFD; |
| bool success = ExportVulkanImage(texture.Get(), layout, &infoOpaqueFD); |
| |
| *static_cast<ExternalImageExportInfoVk*>(exportInfo) = infoOpaqueFD; |
| for (int fd : infoOpaqueFD.semaphoreHandles) { |
| EXPECT_NE(fd, -1); |
| exportInfo->semaphores.push_back(std::make_unique<ExternalSemaphoreOpaqueFD>(fd)); |
| } |
| |
| return success; |
| } |
| |
| private: |
| // Creates a VkImage with external memory |
| ::VkResult CreateImage(dawn::native::vulkan::Device* deviceVk, |
| uint32_t width, |
| uint32_t height, |
| VkFormat format, |
| VkImage* image) { |
| VkExternalMemoryImageCreateInfoKHR externalInfo; |
| externalInfo.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR; |
| externalInfo.pNext = nullptr; |
| externalInfo.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR; |
| |
| auto usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | |
| VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| |
| VkImageCreateInfo createInfo; |
| createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| createInfo.pNext = &externalInfo; |
| createInfo.flags = VK_IMAGE_CREATE_ALIAS_BIT_KHR; |
| createInfo.imageType = VK_IMAGE_TYPE_2D; |
| createInfo.format = format; |
| createInfo.extent = {width, height, 1}; |
| createInfo.mipLevels = 1; |
| createInfo.arrayLayers = 1; |
| createInfo.samples = VK_SAMPLE_COUNT_1_BIT; |
| createInfo.tiling = VK_IMAGE_TILING_OPTIMAL; |
| createInfo.usage = usage; |
| createInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| createInfo.queueFamilyIndexCount = 0; |
| createInfo.pQueueFamilyIndices = nullptr; |
| createInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| |
| return deviceVk->fn.CreateImage(deviceVk->GetVkDevice(), &createInfo, nullptr, |
| &**image); |
| } |
| |
| // Allocates memory for an image |
| ::VkResult AllocateMemory(dawn::native::vulkan::Device* deviceVk, |
| VkImage handle, |
| VkDeviceMemory* allocation, |
| VkDeviceSize* allocationSize, |
| uint32_t* memoryTypeIndex) { |
| // Create the image memory and associate it with the container |
| VkMemoryRequirements requirements; |
| deviceVk->fn.GetImageMemoryRequirements(deviceVk->GetVkDevice(), handle, &requirements); |
| |
| // Import memory from file descriptor |
| VkExportMemoryAllocateInfoKHR externalInfo; |
| externalInfo.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR; |
| externalInfo.pNext = nullptr; |
| externalInfo.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR; |
| |
| int bestType = deviceVk->GetResourceMemoryAllocator()->FindBestTypeIndex( |
| requirements, MemoryKind::Opaque); |
| VkMemoryAllocateInfo allocateInfo; |
| allocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; |
| allocateInfo.pNext = &externalInfo; |
| allocateInfo.allocationSize = requirements.size; |
| allocateInfo.memoryTypeIndex = static_cast<uint32_t>(bestType); |
| |
| *allocationSize = allocateInfo.allocationSize; |
| *memoryTypeIndex = allocateInfo.memoryTypeIndex; |
| |
| return deviceVk->fn.AllocateMemory(deviceVk->GetVkDevice(), &allocateInfo, nullptr, |
| &**allocation); |
| } |
| |
| // Binds memory to an image |
| ::VkResult BindMemory(dawn::native::vulkan::Device* deviceVk, |
| VkImage handle, |
| VkDeviceMemory memory) { |
| return deviceVk->fn.BindImageMemory(deviceVk->GetVkDevice(), handle, memory, 0); |
| } |
| |
| // Extracts a file descriptor representing memory on a device |
| int GetMemoryFd(dawn::native::vulkan::Device* deviceVk, VkDeviceMemory memory) { |
| VkMemoryGetFdInfoKHR getFdInfo; |
| getFdInfo.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR; |
| getFdInfo.pNext = nullptr; |
| getFdInfo.memory = memory; |
| getFdInfo.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR; |
| |
| int memoryFd = -1; |
| deviceVk->fn.GetMemoryFdKHR(deviceVk->GetVkDevice(), &getFdInfo, &memoryFd); |
| |
| EXPECT_GE(memoryFd, 0) << "Failed to get file descriptor for external memory"; |
| return memoryFd; |
| } |
| |
| // Prepares and exports memory for an image on a given device |
| void CreateBindExportImage(dawn::native::vulkan::Device* deviceVk, |
| uint32_t width, |
| uint32_t height, |
| VkFormat format, |
| VkImage* handle, |
| VkDeviceMemory* allocation, |
| VkDeviceSize* allocationSize, |
| uint32_t* memoryTypeIndex, |
| int* memoryFd) { |
| } |
| |
| wgpu::Device mDevice; |
| dawn::native::vulkan::Device* mDeviceVk; |
| }; |
| |
| // static |
| std::unique_ptr<VulkanImageWrappingTestBackend> VulkanImageWrappingTestBackend::Create( |
| const wgpu::Device& device) { |
| return std::make_unique<VulkanImageWrappingTestBackendOpaqueFD>(device); |
| } |
| |
| } // namespace dawn::native::vulkan |