src/tests/white_box/VulkanImageWrappingTests_OpaqueFD.cpp - dawn - Git at Google

 // 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
	// 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