ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues 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

66
test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp
View File

@@ -19,7 +19,7 @@
#include "harness/errorHelpers.h"
#include "harness/deviceInfo.h"
#include <assert.h>
#include <iostream>
#include <algorithm>
#include <stdexcept>
#define ASSERT(x) assert((x))
@@ -887,3 +887,67 @@ cl_semaphore_khr &clExternalSemaphore::getCLSemaphore()
{
return m_externalSemaphore;
}
cl_external_memory_handle_type_khr vkToOpenCLExternalMemoryHandleType(
VulkanExternalMemoryHandleType vkExternalMemoryHandleType)
{
switch (vkExternalMemoryHandleType)
{
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
return CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR;
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
return CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR;
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
return CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR;
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE: return 0;
}
return 0;
}
VulkanImageTiling vkClExternalMemoryHandleTilingAssumption(
cl_device_id deviceId,
VulkanExternalMemoryHandleType vkExternalMemoryHandleType, int *error_ret)
{
size_t size = 0;
VulkanImageTiling mode = VULKAN_IMAGE_TILING_OPTIMAL;
assert(error_ret
!= nullptr); // errcode_ret is not optional, it must be checked
*error_ret = clGetDeviceInfo(
deviceId,
CL_DEVICE_EXTERNAL_MEMORY_IMPORT_ASSUME_LINEAR_IMAGES_HANDLE_TYPES_KHR,
0, nullptr, &size);
if (*error_ret != CL_SUCCESS)
{
return mode;
}
if (size == 0)
{
return mode;
}
std::vector<cl_external_memory_handle_type_khr> assume_linear_types(
size / sizeof(cl_external_memory_handle_type_khr));
*error_ret = clGetDeviceInfo(
deviceId,
CL_DEVICE_EXTERNAL_MEMORY_IMPORT_ASSUME_LINEAR_IMAGES_HANDLE_TYPES_KHR,
size, assume_linear_types.data(), nullptr);
if (*error_ret != CL_SUCCESS)
{
return mode;
}
if (std::find(
assume_linear_types.begin(), assume_linear_types.end(),
vkToOpenCLExternalMemoryHandleType(vkExternalMemoryHandleType))
!= assume_linear_types.end())
{
mode = VULKAN_IMAGE_TILING_LINEAR;
}
return mode;
}

4
test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp
View File

@@ -129,4 +129,8 @@ public:
extern void init_cl_vk_ext(cl_platform_id);
VulkanImageTiling vkClExternalMemoryHandleTilingAssumption(
cl_device_id deviceId,
VulkanExternalMemoryHandleType vkExternalMemoryHandleType, int *error_ret);
#endif // _opencl_vulkan_wrapper_hpp_

8
test_conformance/common/vulkan_wrapper/vulkan_api_list.hpp
View File

@@ -75,6 +75,7 @@
VK_FUNC_DECL(vkDestroyImageView) \
VK_FUNC_DECL(vkCreateImage) \
VK_FUNC_DECL(vkGetImageMemoryRequirements) \
VK_FUNC_DECL(vkGetImageMemoryRequirements2) \
VK_FUNC_DECL(vkDestroyImage) \
VK_FUNC_DECL(vkDestroyBuffer) \
VK_FUNC_DECL(vkDestroyPipeline) \
@@ -87,8 +88,9 @@
VK_FUNC_DECL(vkDestroyDescriptorSetLayout) \
VK_FUNC_DECL(vkGetPhysicalDeviceQueueFamilyProperties) \
VK_FUNC_DECL(vkGetPhysicalDeviceFeatures) \
VK_FUNC_DECL(vkGetPhysicalDeviceProperties2KHR) \
VK_FUNC_DECL(vkGetPhysicalDeviceProperties2) \
VK_FUNC_DECL(vkGetBufferMemoryRequirements) \
VK_FUNC_DECL(vkGetBufferMemoryRequirements2) \
VK_FUNC_DECL(vkGetMemoryFdKHR) \
VK_FUNC_DECL(vkGetSemaphoreFdKHR) \
VK_FUNC_DECL(vkEnumeratePhysicalDeviceGroups) \
@@ -160,6 +162,7 @@
#define vkDestroyImageView _vkDestroyImageView
#define vkCreateImage _vkCreateImage
#define vkGetImageMemoryRequirements _vkGetImageMemoryRequirements
#define vkGetImageMemoryRequirements2 _vkGetImageMemoryRequirements2
#define vkDestroyImage _vkDestroyImage
#define vkDestroyBuffer _vkDestroyBuffer
#define vkDestroyPipeline _vkDestroyPipeline
@@ -173,8 +176,9 @@
#define vkGetPhysicalDeviceQueueFamilyProperties \
_vkGetPhysicalDeviceQueueFamilyProperties
#define vkGetPhysicalDeviceFeatures _vkGetPhysicalDeviceFeatures
#define vkGetPhysicalDeviceProperties2KHR _vkGetPhysicalDeviceProperties2KHR
#define vkGetPhysicalDeviceProperties2 _vkGetPhysicalDeviceProperties2
#define vkGetBufferMemoryRequirements _vkGetBufferMemoryRequirements
#define vkGetBufferMemoryRequirements2 _vkGetBufferMemoryRequirements2
#define vkGetMemoryFdKHR _vkGetMemoryFdKHR
#define vkGetSemaphoreFdKHR _vkGetSemaphoreFdKHR
#define vkEnumeratePhysicalDeviceGroups _vkEnumeratePhysicalDeviceGroups

23
test_conformance/common/vulkan_wrapper/vulkan_list_map.cpp
View File

@@ -141,6 +141,16 @@ VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList() {}
void VulkanDescriptorSetLayoutBindingList::addBinding(
size_t binding, VulkanDescriptorType descriptorType,
uint32_t descriptorCount, VulkanShaderStage shaderStage)
{
VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding =
new VulkanDescriptorSetLayoutBinding(binding, descriptorType,
descriptorCount, shaderStage);
add(*descriptorSetLayoutBinding);
}
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
size_t numDescriptorSetLayoutBindings, VulkanDescriptorType descriptorType,
uint32_t descriptorCount, VulkanShaderStage shaderStage)
@@ -268,6 +278,7 @@ VulkanImage2DList::VulkanImage2DList(
size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory,
uint64_t baseOffset, uint64_t interImageOffset, const VulkanDevice &device,
VulkanFormat format, uint32_t width, uint32_t height, uint32_t mipLevels,
VulkanImageTiling vulkanImageTiling,
VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
VulkanSharingMode sharingMode)
@@ -275,8 +286,8 @@ VulkanImage2DList::VulkanImage2DList(
for (size_t i2DIdx = 0; i2DIdx < numImages; i2DIdx++)
{
VulkanImage2D *image2D = new VulkanImage2D(
device, format, width, height, mipLevels, externalMemoryHandleType,
imageCreateFlag, imageUsage, sharingMode);
device, format, width, height, vulkanImageTiling, mipLevels,
externalMemoryHandleType, imageCreateFlag, imageUsage, sharingMode);
add(*image2D);
deviceMemory[i2DIdx]->bindImage(
*image2D, baseOffset + (i2DIdx * interImageOffset));
@@ -285,16 +296,16 @@ VulkanImage2DList::VulkanImage2DList(
VulkanImage2DList::VulkanImage2DList(
size_t numImages, const VulkanDevice &device, VulkanFormat format,
uint32_t width, uint32_t height, uint32_t mipLevels,
VulkanExternalMemoryHandleType externalMemoryHandleType,
uint32_t width, uint32_t height, VulkanImageTiling vulkanImageTiling,
uint32_t mipLevels, VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
VulkanSharingMode sharingMode)
{
for (size_t bIdx = 0; bIdx < numImages; bIdx++)
{
VulkanImage2D *image2D = new VulkanImage2D(
device, format, width, height, mipLevels, externalMemoryHandleType,
imageCreateFlag, imageUsage, sharingMode);
device, format, width, height, vulkanImageTiling, mipLevels,
externalMemoryHandleType, imageCreateFlag, imageUsage, sharingMode);
add(*image2D);
}
}

8
test_conformance/common/vulkan_wrapper/vulkan_list_map.hpp
View File

@@ -154,6 +154,10 @@ public:
VulkanDescriptorType descriptorType0, uint32_t descriptorCount0,
VulkanDescriptorType descriptorType1, uint32_t descriptorCount1,
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
void
addBinding(size_t binding, VulkanDescriptorType descriptorType,
uint32_t descriptorCount,
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
virtual ~VulkanDescriptorSetLayoutBindingList();
};
@@ -208,6 +212,7 @@ public:
uint64_t baseOffset, uint64_t interImageOffset,
const VulkanDevice &device, VulkanFormat format, uint32_t width,
uint32_t height, uint32_t mipLevels,
VulkanImageTiling vulkanImageTiling,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
@@ -216,7 +221,8 @@ public:
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
VulkanImage2DList(
size_t numImages, const VulkanDevice &device, VulkanFormat format,
uint32_t width, uint32_t height, uint32_t mipLevels = 1,
uint32_t width, uint32_t height, VulkanImageTiling vulkanImageTiling,
uint32_t mipLevels = 1,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,

1
test_conformance/common/vulkan_wrapper/vulkan_utility.cpp
View File

@@ -21,6 +21,7 @@
#include <fstream>
#include <set>
#include <string>
#include <algorithm>
#include <CL/cl.h>
#include <CL/cl_ext.h>
#if defined(_WIN32) || defined(_WIN64)

3
test_conformance/common/vulkan_wrapper/vulkan_utility.hpp
View File

@@ -33,7 +33,8 @@
const VulkanInstance& getVulkanInstance();
const VulkanPhysicalDevice& getVulkanPhysicalDevice();
const VulkanQueueFamily&
getVulkanQueueFamily(uint32_t queueFlags = VULKAN_QUEUE_FLAG_MASK_ALL);
getVulkanQueueFamily(uint32_t queueFlags = VULKAN_QUEUE_FLAG_GRAPHICS
| VULKAN_QUEUE_FLAG_COMPUTE);
const VulkanMemoryType&
getVulkanMemoryType(const VulkanDevice& device,
VulkanMemoryTypeProperty memoryTypeProperty);

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);
}

20
test_conformance/common/vulkan_wrapper/vulkan_wrapper.hpp
View File

@@ -328,7 +328,11 @@ public:
const VulkanDescriptorSetLayout &descriptorSetLayout);
virtual ~VulkanDescriptorSet();
void update(uint32_t binding, const VulkanBuffer &buffer);
void updateArray(uint32_t binding, unsigned numBuffers,
const VulkanBufferList &buffers);
void update(uint32_t binding, const VulkanImageView &imageView);
void updateArray(uint32_t binding,
const VulkanImageViewList &imageViewList);
operator VkDescriptorSet() const;
};
@@ -424,6 +428,7 @@ protected:
VkBuffer m_vkBuffer;
uint64_t m_size;
uint64_t m_alignment;
bool m_dedicated;
VulkanMemoryTypeList m_memoryTypeList;
VulkanBuffer(const VulkanBuffer &buffer);
@@ -441,6 +446,7 @@ public:
uint64_t getSize() const;
uint64_t getAlignment() const;
const VulkanMemoryTypeList &getMemoryTypeList() const;
bool isDedicated() const;
operator VkBuffer() const;
};
@@ -452,6 +458,7 @@ protected:
const VulkanFormat m_format;
const uint32_t m_numMipLevels;
const uint32_t m_numLayers;
bool m_dedicated;
VkImage m_vkImage;
uint64_t m_size;
uint64_t m_alignment;
@@ -478,6 +485,7 @@ public:
uint32_t getNumLayers() const;
uint64_t getSize() const;
uint64_t getAlignment() const;
bool isDedicated() const;
const VulkanMemoryTypeList &getMemoryTypeList() const;
VkImageCreateInfo getVkImageCreateInfo() const;
operator VkImage() const;
@@ -487,12 +495,11 @@ class VulkanImage2D : public VulkanImage {
protected:
VkImageView m_vkImageView;
VulkanImage2D(const VulkanImage2D &image2D);
public:
VulkanImage2D(
const VulkanDevice &device, VulkanFormat format, uint32_t width,
uint32_t height, uint32_t numMipLevels = 1,
uint32_t height, VulkanImageTiling imageTiling,
uint32_t numMipLevels = 1,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
@@ -501,6 +508,8 @@ public:
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
virtual ~VulkanImage2D();
virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const;
VulkanImage2D(const VulkanImage2D &image2D);
};
class VulkanImageView {
@@ -541,6 +550,11 @@ public:
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
const void *name = NULL);
VulkanDeviceMemory(const VulkanDevice &device, const VulkanBuffer &buffer,
const VulkanMemoryType &memoryType,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
const void *name = NULL);
virtual ~VulkanDeviceMemory();
uint64_t getSize() const;
#ifdef _WIN32