ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 22:19:02 +00:00
Code Packages Projects Releases Wiki Activity

External memory updates (#1676)

Browse Source 
* Vulkan: Fix descriptor sets

Use descriptor set arrays when programming
arrays for compute shader.

Change-Id: Idabab775a256a223660eb7a850e26f290453659e

* Vulkan: Fix queue propertyies

Transfer bit for queue family is not required
to be reported by the implementation, it is
implicit for compute.

Change-Id: I7424b00e25e35145433dd74b0b4dfe7eeeaf98c8

* Vulkan: Allow implementation to choose dedicated memory

Dedicated vs non-dedicated memory must be queried by
the app.  Implementations are not required to support
exportable non-dedicated memory.

Change-Id: Idbc46ace1be20f61d1b58b34756f6d79a7745911

* Fix formatting

Auto-generated formatting fix

* Fix bug in dedicated memory.

* Add check for if OpenCL assumes linear tiling

Change-Id: Idd2e24d9d69e1fbc3ccb4a279067533104185332

* Changed macro name to reflect spec

CL_DEVICE_EXTERNAL_MEMORY_IMPORT_ASSUME_LINEAR_HANDLE_TYPES_KHR to
CL_DEVICE_EXTERNAL_MEMORY_IMPORT_ASSUME_LINEAR_IMAGES_HANDLE_TYPES_KHR

Also changed some functions to not use the KHR variants.

---------

Co-authored-by: Joshua Kelly <joshkell@qti.qualcomm.com>
This commit is contained in:
Sreelakshmi Haridas Maruthur
2023-09-05 10:04:38 -06:00
committed by GitHub
parent c511ac62b0
commit 15b54aa0bd
14 changed files with 518 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

241
test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp
View File

@@ -74,7 +74,7 @@ VulkanInstance::VulkanInstance(): m_vkInstance(VK_NULL_HANDLE)
const char *vulkanLoaderLibraryName = "vulkan-1.dll";
#elif defined(__ANDROID__)
const char *vulkanLoaderLibraryName = "libvulkan.so";
#elif defined(__linux__)
#else
const char *vulkanLoaderLibraryName = "libvulkan.so.1";
#endif
#ifdef _WIN32
@@ -276,13 +276,13 @@ VulkanPhysicalDevice::VulkanPhysicalDevice(VkPhysicalDevice vkPhysicalDevice)
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR;
vkPhysicalDeviceIDPropertiesKHR.pNext = NULL;
VkPhysicalDeviceProperties2KHR vkPhysicalDeviceProperties2KHR = {};
vkPhysicalDeviceProperties2KHR.sType =
VkPhysicalDeviceProperties2 vkPhysicalDeviceProperties2 = {};
vkPhysicalDeviceProperties2.sType =
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
vkPhysicalDeviceProperties2KHR.pNext = &vkPhysicalDeviceIDPropertiesKHR;
vkPhysicalDeviceProperties2.pNext = &vkPhysicalDeviceIDPropertiesKHR;
vkGetPhysicalDeviceProperties2KHR(m_vkPhysicalDevice,
&vkPhysicalDeviceProperties2KHR);
vkGetPhysicalDeviceProperties2(m_vkPhysicalDevice,
&vkPhysicalDeviceProperties2);
memcpy(m_vkDeviceUUID, vkPhysicalDeviceIDPropertiesKHR.deviceUUID,
sizeof(m_vkDeviceUUID));
@@ -1013,12 +1013,14 @@ void VulkanDescriptorPool::VulkanDescriptorPoolCommon(
== vkDescriptorTypeToDescriptorCountMap.end())
{
vkDescriptorTypeToDescriptorCountMap
[vkDescriptorSetLayoutBinding.descriptorType] = 1;
[vkDescriptorSetLayoutBinding.descriptorType] =
vkDescriptorSetLayoutBinding.descriptorCount;
}
else
{
vkDescriptorTypeToDescriptorCountMap
[vkDescriptorSetLayoutBinding.descriptorType]++;
[vkDescriptorSetLayoutBinding.descriptorType] +=
vkDescriptorSetLayoutBinding.descriptorCount;
}
}
@@ -1159,6 +1161,35 @@ void VulkanDescriptorSet::update(uint32_t binding, const VulkanBuffer &buffer)
vkUpdateDescriptorSets(m_device, 1, &vkWriteDescriptorSet, 0, NULL);
}
void VulkanDescriptorSet::updateArray(uint32_t binding, unsigned numBuffers,
const VulkanBufferList &buffers)
{
VkDescriptorBufferInfo *vkDescriptorBufferInfo =
(VkDescriptorBufferInfo *)calloc(numBuffers,
sizeof(VkDescriptorBufferInfo));
for (unsigned i = 0; i < numBuffers; i++)
{
vkDescriptorBufferInfo[i].buffer = buffers[i];
vkDescriptorBufferInfo[i].offset = 0;
vkDescriptorBufferInfo[i].range = VK_WHOLE_SIZE;
}
VkWriteDescriptorSet vkWriteDescriptorSet = {};
vkWriteDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
vkWriteDescriptorSet.pNext = NULL;
vkWriteDescriptorSet.dstSet = m_vkDescriptorSet;
vkWriteDescriptorSet.dstBinding = binding;
vkWriteDescriptorSet.dstArrayElement = 0;
vkWriteDescriptorSet.descriptorCount = numBuffers;
vkWriteDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
vkWriteDescriptorSet.pImageInfo = NULL;
vkWriteDescriptorSet.pBufferInfo = vkDescriptorBufferInfo;
vkWriteDescriptorSet.pTexelBufferView = NULL;
vkUpdateDescriptorSets(m_device, 1, &vkWriteDescriptorSet, 0, NULL);
free(vkDescriptorBufferInfo);
}
void VulkanDescriptorSet::update(uint32_t binding,
const VulkanImageView &imageView)
{
@@ -1182,6 +1213,34 @@ void VulkanDescriptorSet::update(uint32_t binding,
vkUpdateDescriptorSets(m_device, 1, &vkWriteDescriptorSet, 0, NULL);
}
void VulkanDescriptorSet::updateArray(uint32_t binding,
const VulkanImageViewList &imageViewList)
{
VkDescriptorImageInfo *vkDescriptorImageInfo =
new VkDescriptorImageInfo[imageViewList.size()];
for (size_t i = 0; i < imageViewList.size(); i++)
{
vkDescriptorImageInfo[i].sampler = VK_NULL_HANDLE;
vkDescriptorImageInfo[i].imageView = imageViewList[i];
vkDescriptorImageInfo[i].imageLayout = VK_IMAGE_LAYOUT_GENERAL;
}
VkWriteDescriptorSet vkWriteDescriptorSet = {};
vkWriteDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
vkWriteDescriptorSet.pNext = NULL;
vkWriteDescriptorSet.dstSet = m_vkDescriptorSet;
vkWriteDescriptorSet.dstBinding = binding;
vkWriteDescriptorSet.dstArrayElement = 0;
vkWriteDescriptorSet.descriptorCount = imageViewList.size();
vkWriteDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
vkWriteDescriptorSet.pImageInfo = vkDescriptorImageInfo;
vkWriteDescriptorSet.pBufferInfo = NULL;
vkWriteDescriptorSet.pTexelBufferView = NULL;
vkUpdateDescriptorSets(m_device, 1, &vkWriteDescriptorSet, 0, NULL);
delete[] vkDescriptorImageInfo;
}
VulkanDescriptorSet::operator VkDescriptorSet() const
{
return m_vkDescriptorSet;
@@ -1505,12 +1564,14 @@ VulkanBuffer::VulkanBuffer(const VulkanBuffer &buffer)
m_memoryTypeList(buffer.m_memoryTypeList)
{}
bool VulkanBuffer::isDedicated() const { return m_dedicated; }
VulkanBuffer::VulkanBuffer(
const VulkanDevice &device, uint64_t size,
VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanBufferUsage bufferUsage, VulkanSharingMode sharingMode,
const VulkanQueueFamilyList &queueFamilyList)
: m_device(device), m_vkBuffer(VK_NULL_HANDLE)
: m_device(device), m_vkBuffer(VK_NULL_HANDLE), m_dedicated(false)
{
std::vector<uint32_t> queueFamilyIndexList;
if (queueFamilyList.size() == 0)
@@ -1556,16 +1617,36 @@ VulkanBuffer::VulkanBuffer(
vkCreateBuffer(m_device, &vkBufferCreateInfo, NULL, &m_vkBuffer);
VkMemoryRequirements vkMemoryRequirements = {};
vkGetBufferMemoryRequirements(m_device, m_vkBuffer, &vkMemoryRequirements);
m_size = vkMemoryRequirements.size;
m_alignment = vkMemoryRequirements.alignment;
VkMemoryDedicatedRequirements vkMemoryDedicatedRequirements = {};
vkMemoryDedicatedRequirements.sType =
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
vkMemoryDedicatedRequirements.pNext = NULL;
VkMemoryRequirements2 vkMemoryRequirements = {};
vkMemoryRequirements.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
vkMemoryRequirements.pNext = &vkMemoryDedicatedRequirements;
VkBufferMemoryRequirementsInfo2 vkMemoryRequirementsInfo = {};
vkMemoryRequirementsInfo.sType =
VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
vkMemoryRequirementsInfo.buffer = m_vkBuffer;
vkMemoryRequirementsInfo.pNext = NULL;
vkGetBufferMemoryRequirements2(m_device, &vkMemoryRequirementsInfo,
&vkMemoryRequirements);
m_dedicated = vkMemoryDedicatedRequirements.requiresDedicatedAllocation;
m_size = vkMemoryRequirements.memoryRequirements.size;
m_alignment = vkMemoryRequirements.memoryRequirements.alignment;
const VulkanMemoryTypeList &memoryTypeList =
m_device.getPhysicalDevice().getMemoryTypeList();
for (size_t mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++)
{
uint32_t memoryTypeIndex = memoryTypeList[mtIdx];
if ((1 << memoryTypeIndex) & vkMemoryRequirements.memoryTypeBits)
if ((1 << memoryTypeIndex)
& vkMemoryRequirements.memoryRequirements.memoryTypeBits)
{
m_memoryTypeList.add(memoryTypeList[mtIdx]);
}
@@ -1640,16 +1721,36 @@ VulkanImage::VulkanImage(
vkCreateImage(m_device, &vkImageCreateInfo, NULL, &m_vkImage);
VulkanImageCreateInfo = vkImageCreateInfo;
VkMemoryRequirements vkMemoryRequirements = {};
vkGetImageMemoryRequirements(m_device, m_vkImage, &vkMemoryRequirements);
m_size = vkMemoryRequirements.size;
m_alignment = vkMemoryRequirements.alignment;
VkMemoryDedicatedRequirements vkMemoryDedicatedRequirements = {};
vkMemoryDedicatedRequirements.sType =
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
vkMemoryDedicatedRequirements.pNext = NULL;
VkMemoryRequirements2 vkMemoryRequirements = {};
vkMemoryRequirements.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
vkMemoryRequirements.pNext = &vkMemoryDedicatedRequirements;
VkImageMemoryRequirementsInfo2 vkMemoryRequirementsInfo = {};
vkMemoryRequirementsInfo.sType =
VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
vkMemoryRequirementsInfo.image = m_vkImage;
vkMemoryRequirementsInfo.pNext = NULL;
vkGetImageMemoryRequirements2(m_device, &vkMemoryRequirementsInfo,
&vkMemoryRequirements);
m_size = vkMemoryRequirements.memoryRequirements.size;
m_alignment = vkMemoryRequirements.memoryRequirements.alignment;
m_dedicated = vkMemoryDedicatedRequirements.requiresDedicatedAllocation;
const VulkanMemoryTypeList &memoryTypeList =
m_device.getPhysicalDevice().getMemoryTypeList();
for (size_t mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++)
{
uint32_t memoryTypeIndex = memoryTypeList[mtIdx];
if ((1 << memoryTypeIndex) & vkMemoryRequirements.memoryTypeBits)
if ((1 << memoryTypeIndex)
& vkMemoryRequirements.memoryRequirements.memoryTypeBits)
{
m_memoryTypeList.add(memoryTypeList[mtIdx]);
}
@@ -1678,6 +1779,8 @@ uint64_t VulkanImage::getSize() const { return m_size; }
uint64_t VulkanImage::getAlignment() const { return m_alignment; }
bool VulkanImage::isDedicated() const { return m_dedicated; }
const VulkanMemoryTypeList &VulkanImage::getMemoryTypeList() const
{
return m_memoryTypeList;
@@ -1694,14 +1797,14 @@ VulkanImage2D::VulkanImage2D(const VulkanImage2D &image2D): VulkanImage(image2D)
VulkanImage2D::VulkanImage2D(
const VulkanDevice &device, VulkanFormat format, uint32_t width,
uint32_t height, uint32_t numMipLevels,
uint32_t height, VulkanImageTiling imageTiling, uint32_t numMipLevels,
VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
VulkanSharingMode sharingMode)
: VulkanImage(device, VULKAN_IMAGE_TYPE_2D, format,
VulkanExtent3D(width, height, 1), numMipLevels, 1,
externalMemoryHandleType, imageCreateFlag,
VULKAN_IMAGE_TILING_OPTIMAL, imageUsage, sharingMode)
externalMemoryHandleType, imageCreateFlag, imageTiling,
imageUsage, sharingMode)
{}
VulkanImage2D::~VulkanImage2D() {}
@@ -1888,7 +1991,8 @@ VulkanDeviceMemory::VulkanDeviceMemory(
const VulkanDevice &device, const VulkanImage &image,
const VulkanMemoryType &memoryType,
VulkanExternalMemoryHandleType externalMemoryHandleType, const void *name)
: m_device(device), m_size(image.getSize()), m_isDedicated(true)
: m_device(device), m_size(image.getSize()),
m_isDedicated(image.isDedicated())
{
#if defined(_WIN32) || defined(_WIN64)
WindowsSecurityAttributes winSecurityAttributes;
@@ -1921,20 +2025,95 @@ VulkanDeviceMemory::VulkanDeviceMemory(
VkMemoryDedicatedAllocateInfo vkMemoryDedicatedAllocateInfo = {};
vkMemoryDedicatedAllocateInfo.sType =
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
vkMemoryDedicatedAllocateInfo.pNext =
externalMemoryHandleType ? &vkExportMemoryAllocateInfoKHR : NULL;
vkMemoryDedicatedAllocateInfo.pNext = NULL;
vkMemoryDedicatedAllocateInfo.image = image;
vkMemoryDedicatedAllocateInfo.buffer = VK_NULL_HANDLE;
VkMemoryAllocateInfo vkMemoryAllocateInfo = {};
vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
vkMemoryAllocateInfo.pNext = &vkMemoryDedicatedAllocateInfo;
vkMemoryAllocateInfo.allocationSize = m_size;
vkMemoryAllocateInfo.memoryTypeIndex = (uint32_t)memoryType;
if (m_isDedicated)
{
vkMemoryAllocateInfo.pNext = &vkMemoryDedicatedAllocateInfo;
vkMemoryDedicatedAllocateInfo.pNext =
externalMemoryHandleType ? &vkExportMemoryAllocateInfoKHR : NULL;
}
else
{
vkMemoryAllocateInfo.pNext =
externalMemoryHandleType ? &vkExportMemoryAllocateInfoKHR : NULL;
}
vkAllocateMemory(m_device, &vkMemoryAllocateInfo, NULL, &m_vkDeviceMemory);
}
VulkanDeviceMemory::VulkanDeviceMemory(
const VulkanDevice &device, const VulkanBuffer &buffer,
const VulkanMemoryType &memoryType,
VulkanExternalMemoryHandleType externalMemoryHandleType, const void *name)
: m_device(device), m_size(buffer.getSize()),
m_isDedicated(buffer.isDedicated())
{
#if defined(_WIN32) || defined(_WIN64)
WindowsSecurityAttributes winSecurityAttributes;
VkExportMemoryWin32HandleInfoKHR vkExportMemoryWin32HandleInfoKHR = {};
vkExportMemoryWin32HandleInfoKHR.sType =
VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
vkExportMemoryWin32HandleInfoKHR.pNext = NULL;
vkExportMemoryWin32HandleInfoKHR.pAttributes = &winSecurityAttributes;
vkExportMemoryWin32HandleInfoKHR.dwAccess =
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE;
vkExportMemoryWin32HandleInfoKHR.name = (LPCWSTR)name;
#endif
VkExportMemoryAllocateInfoKHR vkExportMemoryAllocateInfoKHR = {};
vkExportMemoryAllocateInfoKHR.sType =
VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR;
#if defined(_WIN32) || defined(_WIN64)
vkExportMemoryAllocateInfoKHR.pNext = externalMemoryHandleType
& VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT
? &vkExportMemoryWin32HandleInfoKHR
: NULL;
#else
vkExportMemoryAllocateInfoKHR.pNext = NULL;
#endif
vkExportMemoryAllocateInfoKHR.handleTypes =
(VkExternalMemoryHandleTypeFlagsKHR)externalMemoryHandleType;
VkMemoryDedicatedAllocateInfo vkMemoryDedicatedAllocateInfo = {};
vkMemoryDedicatedAllocateInfo.sType =
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
vkMemoryDedicatedAllocateInfo.pNext = NULL;
vkMemoryDedicatedAllocateInfo.image = VK_NULL_HANDLE;
vkMemoryDedicatedAllocateInfo.buffer = buffer;
VkMemoryAllocateInfo vkMemoryAllocateInfo = {};
vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
vkMemoryAllocateInfo.allocationSize = m_size;
vkMemoryAllocateInfo.memoryTypeIndex = (uint32_t)memoryType;
if (m_isDedicated)
{
vkMemoryAllocateInfo.pNext = &vkMemoryDedicatedAllocateInfo;
vkMemoryDedicatedAllocateInfo.pNext =
externalMemoryHandleType ? &vkExportMemoryAllocateInfoKHR : NULL;
}
else
{
vkMemoryAllocateInfo.pNext =
externalMemoryHandleType ? &vkExportMemoryAllocateInfoKHR : NULL;
}
VkResult res = vkAllocateMemory(m_device, &vkMemoryAllocateInfo, NULL,
&m_vkDeviceMemory);
ASSERT_SUCCESS(res, "Failed to allocate device memory");
}
VulkanDeviceMemory::~VulkanDeviceMemory()
{
vkFreeMemory(m_device, m_vkDeviceMemory, NULL);
@@ -2001,11 +2180,21 @@ void VulkanDeviceMemory::unmap() { vkUnmapMemory(m_device, m_vkDeviceMemory); }
void VulkanDeviceMemory::bindBuffer(const VulkanBuffer &buffer, uint64_t offset)
{
if (buffer.isDedicated() && !m_isDedicated)
{
throw std::runtime_error(
"Buffer requires dedicated memory. Failed to bind");
}
vkBindBufferMemory(m_device, buffer, m_vkDeviceMemory, offset);
}
void VulkanDeviceMemory::bindImage(const VulkanImage &image, uint64_t offset)
{
if (image.isDedicated() && !m_isDedicated)
{
throw std::runtime_error(
"Image requires dedicated memory. Failed to bind");
}
vkBindImageMemory(m_device, image, m_vkDeviceMemory, offset);
}