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

5
test_conformance/vulkan/main.cpp
View File

@@ -185,7 +185,6 @@ bool useSingleImageKernel = false;
bool useDeviceLocal = false;
bool disableNTHandleType = false;
bool enableOffset = false;
bool non_dedicated = false;
static void printUsage(const char *execName)
{
@@ -232,10 +231,6 @@ size_t parseParams(int argc, const char *argv[], const char **argList)
{
enableOffset = true;
}
if (!strcmp(argv[i], "--non_dedicated"))
{
non_dedicated = true;
}
if (strcmp(argv[i], "-h") == 0)
{
printUsage(argv[0]);

30
test_conformance/vulkan/test_vulkan_api_consistency.cpp
View File

@@ -81,10 +81,11 @@ int test_consistency_external_buffer(cl_device_id deviceID, cl_context _context,
const VulkanMemoryTypeList& memoryTypeList =
vkDummyBuffer.getMemoryTypeList();
VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(
vkDevice, bufferSize, memoryTypeList[0], vkExternalMemoryHandleType);
VulkanBufferList vkBufferList(1, vkDevice, bufferSize,
vkExternalMemoryHandleType);
VulkanDeviceMemory* vkDeviceMem =
new VulkanDeviceMemory(vkDevice, vkBufferList[0], memoryTypeList[0],
vkExternalMemoryHandleType);
vkDeviceMem->bindBuffer(vkBufferList[0], 0);
@@ -231,22 +232,27 @@ int test_consistency_external_image(cl_device_id deviceID, cl_context _context,
VulkanExternalMemoryHandleType vkExternalMemoryHandleType =
getSupportedVulkanExternalMemoryHandleTypeList()[0];
VulkanImage2D* vkImage2D =
new VulkanImage2D(vkDevice, VULKAN_FORMAT_R8G8B8A8_UNORM, width, height,
1, vkExternalMemoryHandleType);
const VulkanMemoryTypeList& memoryTypeList = vkImage2D->getMemoryTypeList();
uint64_t totalImageMemSize = vkImage2D->getSize();
VulkanImageTiling vulkanImageTiling =
vkClExternalMemoryHandleTilingAssumption(
deviceID, vkExternalMemoryHandleType, &errNum);
ASSERT_SUCCESS(errNum, "Failed to query OpenCL tiling mode");
VulkanImage2D vkImage2D =
VulkanImage2D(vkDevice, VULKAN_FORMAT_R8G8B8A8_UNORM, width, height,
vulkanImageTiling, 1, vkExternalMemoryHandleType);
const VulkanMemoryTypeList& memoryTypeList = vkImage2D.getMemoryTypeList();
uint64_t totalImageMemSize = vkImage2D.getSize();
log_info("Memory type index: %lu\n", (uint32_t)memoryTypeList[0]);
log_info("Memory type property: %d\n",
memoryTypeList[0].getMemoryTypeProperty());
log_info("Image size : %d\n", totalImageMemSize);
VulkanDeviceMemory* vkDeviceMem =
new VulkanDeviceMemory(vkDevice, totalImageMemSize, memoryTypeList[0],
vkExternalMemoryHandleType);
vkDeviceMem->bindImage(*vkImage2D, 0);
VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(
vkDevice, vkImage2D, memoryTypeList[0], vkExternalMemoryHandleType);
vkDeviceMem->bindImage(vkImage2D, 0);
void* handle = NULL;
int fd;
@@ -299,7 +305,7 @@ int test_consistency_external_image(cl_device_id deviceID, cl_context _context,
extMemProperties.push_back(0);
const VkImageCreateInfo VulkanImageCreateInfo =
vkImage2D->getVkImageCreateInfo();
vkImage2D.getVkImageCreateInfo();
errNum = getCLImageInfoFromVkImageInfo(
&VulkanImageCreateInfo, totalImageMemSize, &img_format, &image_desc);

43
test_conformance/vulkan/test_vulkan_interop_buffer.cpp
View File

@@ -126,8 +126,11 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
std::vector<char> vkBufferShader = readFile("buffer.spv");
VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList(
MAX_BUFFERS + 1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
vkDescriptorSetLayoutBindingList.addBinding(
0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_BUFFERS);
VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout);
@@ -189,9 +192,9 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
for (size_t bIdx = 0; bIdx < numBuffers; bIdx++)
{
vkBufferListDeviceMemory.push_back(
new VulkanDeviceMemory(vkDevice, bufferSize, memoryType,
vkExternalMemoryHandleType));
vkBufferListDeviceMemory.push_back(new VulkanDeviceMemory(
vkDevice, vkBufferList[bIdx], memoryType,
vkExternalMemoryHandleType));
externalMemory.push_back(new clExternalMemory(
vkBufferListDeviceMemory[bIdx], vkExternalMemoryHandleType,
0, bufferSize, context, deviceId));
@@ -210,8 +213,8 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
vkBufferListDeviceMemory[bIdx]->bindBuffer(vkBufferList[bIdx],
0);
buffers[bIdx] = externalMemory[bIdx]->getExternalMemoryBuffer();
vkDescriptorSet.update((uint32_t)bIdx + 1, vkBufferList[bIdx]);
}
vkDescriptorSet.updateArray(1, numBuffers, vkBufferList);
vkCommandBuffer.begin();
vkCommandBuffer.bindPipeline(vkComputePipeline);
vkCommandBuffer.bindDescriptorSets(
@@ -453,8 +456,11 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
std::vector<char> vkBufferShader = readFile("buffer.spv");
VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList(
MAX_BUFFERS + 1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
vkDescriptorSetLayoutBindingList.addBinding(
0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_BUFFERS);
VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout);
@@ -517,9 +523,9 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
for (size_t bIdx = 0; bIdx < numBuffers; bIdx++)
{
vkBufferListDeviceMemory.push_back(
new VulkanDeviceMemory(vkDevice, bufferSize, memoryType,
vkExternalMemoryHandleType));
vkBufferListDeviceMemory.push_back(new VulkanDeviceMemory(
vkDevice, vkBufferList[bIdx], memoryType,
vkExternalMemoryHandleType));
externalMemory.push_back(new clExternalMemory(
vkBufferListDeviceMemory[bIdx], vkExternalMemoryHandleType,
0, bufferSize, context, deviceId));
@@ -538,8 +544,9 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
vkBufferListDeviceMemory[bIdx]->bindBuffer(vkBufferList[bIdx],
0);
buffers[bIdx] = externalMemory[bIdx]->getExternalMemoryBuffer();
vkDescriptorSet.update((uint32_t)bIdx + 1, vkBufferList[bIdx]);
}
vkDescriptorSet.updateArray(1, vkBufferList.size(), vkBufferList);
vkCommandBuffer.begin();
vkCommandBuffer.bindPipeline(vkComputePipeline);
vkCommandBuffer.bindDescriptorSets(
@@ -754,8 +761,11 @@ int run_test_with_multi_import_same_ctx(
std::vector<char> vkBufferShader = readFile("buffer.spv");
VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList(
MAX_BUFFERS + 1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
vkDescriptorSetLayoutBindingList.addBinding(
0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_BUFFERS);
VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout);
@@ -836,7 +846,7 @@ int run_test_with_multi_import_same_ctx(
if (withOffset == 0)
{
vkBufferListDeviceMemory.push_back(
new VulkanDeviceMemory(vkDevice, pBufferSize,
new VulkanDeviceMemory(vkDevice, vkBufferList[bIdx],
memoryType,
vkExternalMemoryHandleType));
}
@@ -880,9 +890,8 @@ int run_test_with_multi_import_same_ctx(
externalMemory[bIdx][cl_bIdx]
->getExternalMemoryBuffer();
}
vkDescriptorSet.update((uint32_t)bIdx + 1,
vkBufferList[bIdx]);
}
vkDescriptorSet.updateArray(1, numBuffers, vkBufferList);
vkCommandBuffer.begin();
vkCommandBuffer.bindPipeline(vkComputePipeline);
vkCommandBuffer.bindDescriptorSets(

332
test_conformance/vulkan/test_vulkan_interop_image.cpp
View File

@@ -226,9 +226,11 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
srcBufferPtr = (char *)malloc(maxImage2DSize);
dstBufferPtr = (char *)malloc(maxImage2DSize);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList(
VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1,
VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_2D_IMAGE_DESCRIPTORS);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
vkDescriptorSetLayoutBindingList.addBinding(
0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_2D_IMAGE_DESCRIPTORS);
VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout);
@@ -255,10 +257,10 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
clCl2VkExternalSemaphore = new clExternalSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
std::vector<VulkanDeviceMemory *> vkNonDedicatedImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkNonDedicatedImage2DListDeviceMemory2;
std::vector<clExternalMemoryImage *> nonDedicatedExternalMemory1;
std::vector<clExternalMemoryImage *> nonDedicatedExternalMemory2;
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2;
std::vector<clExternalMemoryImage *> externalMemory1;
std::vector<clExternalMemoryImage *> externalMemory2;
std::vector<char> vkImage2DShader;
for (size_t fIdx = 0; fIdx < vkFormatList.size(); fIdx++)
@@ -352,8 +354,6 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
VulkanExternalMemoryHandleType
vkExternalMemoryHandleType =
vkExternalMemoryHandleTypeList[emhtIdx];
log_info("External memory handle type: %d \n",
vkExternalMemoryHandleType);
if ((true == disableNTHandleType)
&& (VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT
== vkExternalMemoryHandleType))
@@ -361,9 +361,19 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
// Skip running for WIN32 NT handle.
continue;
}
log_info("External memory handle type: %d \n",
vkExternalMemoryHandleType);
VulkanImageTiling vulkanImageTiling =
vkClExternalMemoryHandleTilingAssumption(
deviceId,
vkExternalMemoryHandleTypeList[emhtIdx], &err);
ASSERT_SUCCESS(err,
"Failed to query OpenCL tiling mode");
VulkanImage2D vkDummyImage2D(
vkDevice, vkFormatList[0], widthList[0],
heightList[0], 1, vkExternalMemoryHandleType);
heightList[0], vulkanImageTiling, 1,
vkExternalMemoryHandleType);
const VulkanMemoryTypeList &memoryTypeList =
vkDummyImage2D.getMemoryTypeList();
@@ -390,118 +400,73 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
{
VulkanImage2D vkImage2D(
vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType);
vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
ASSERT_LEQ(vkImage2D.getSize(), maxImage2DSize);
totalImageMemSize =
ROUND_UP(vkImage2D.getSize(),
vkImage2D.getAlignment());
}
VulkanImage2DList vkNonDedicatedImage2DList(
VulkanImage2DList vkImage2DList(
num2DImages, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType);
vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
for (size_t bIdx = 0; bIdx < num2DImages; bIdx++)
{
if (non_dedicated)
{
vkNonDedicatedImage2DListDeviceMemory1
.push_back(new VulkanDeviceMemory(
vkDevice, totalImageMemSize,
memoryType,
vkExternalMemoryHandleType));
}
else
{
vkNonDedicatedImage2DListDeviceMemory1
.push_back(new VulkanDeviceMemory(
vkDevice,
vkNonDedicatedImage2DList[bIdx],
memoryType,
vkExternalMemoryHandleType));
}
vkNonDedicatedImage2DListDeviceMemory1[bIdx]
->bindImage(vkNonDedicatedImage2DList[bIdx],
0);
nonDedicatedExternalMemory1.push_back(
vkImage2DListDeviceMemory1.push_back(
new VulkanDeviceMemory(
vkDevice, vkImage2DList[bIdx],
memoryType,
vkExternalMemoryHandleType));
vkImage2DListDeviceMemory1[bIdx]->bindImage(
vkImage2DList[bIdx], 0);
externalMemory1.push_back(
new clExternalMemoryImage(
*vkNonDedicatedImage2DListDeviceMemory1
[bIdx],
*vkImage2DListDeviceMemory1[bIdx],
vkExternalMemoryHandleType, context,
totalImageMemSize, width, height, 0,
vkNonDedicatedImage2DList[bIdx],
deviceId));
vkImage2DList[bIdx], deviceId));
}
VulkanImageViewList vkNonDedicatedImage2DViewList(
vkDevice, vkNonDedicatedImage2DList);
VulkanImage2DList vkNonDedicatedImage2DList2(
VulkanImageViewList vkImage2DViewList(
vkDevice, vkImage2DList);
VulkanImage2DList vkImage2DList2(
num2DImages, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType);
vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
for (size_t bIdx = 0; bIdx < num2DImages; bIdx++)
{
if (non_dedicated)
{
vkNonDedicatedImage2DListDeviceMemory2
.push_back(new VulkanDeviceMemory(
vkDevice, totalImageMemSize,
memoryType,
vkExternalMemoryHandleType));
}
else
{
vkNonDedicatedImage2DListDeviceMemory2
.push_back(new VulkanDeviceMemory(
vkDevice,
vkNonDedicatedImage2DList2[bIdx],
memoryType,
vkExternalMemoryHandleType));
}
vkNonDedicatedImage2DListDeviceMemory2[bIdx]
->bindImage(
vkNonDedicatedImage2DList2[bIdx], 0);
nonDedicatedExternalMemory2.push_back(
vkImage2DListDeviceMemory2.push_back(
new VulkanDeviceMemory(
vkDevice, vkImage2DList2[bIdx],
memoryType,
vkExternalMemoryHandleType));
vkImage2DListDeviceMemory2[bIdx]->bindImage(
vkImage2DList2[bIdx], 0);
externalMemory2.push_back(
new clExternalMemoryImage(
*vkNonDedicatedImage2DListDeviceMemory2
[bIdx],
*vkImage2DListDeviceMemory2[bIdx],
vkExternalMemoryHandleType, context,
totalImageMemSize, width, height, 0,
vkNonDedicatedImage2DList2[bIdx],
deviceId));
vkImage2DList2[bIdx], deviceId));
}
VulkanImageViewList vkDedicatedImage2DViewList(
vkDevice, vkNonDedicatedImage2DList2);
cl_mem external_mem_image1[5];
cl_mem external_mem_image2[5];
for (int i = 0; i < num2DImages; i++)
{
external_mem_image1[i] =
nonDedicatedExternalMemory1[i]
externalMemory1[i]
->getExternalMemoryImage();
external_mem_image2[i] =
nonDedicatedExternalMemory2[i]
externalMemory2[i]
->getExternalMemoryImage();
}
VulkanImage2DList &vkImage2DList =
vkNonDedicatedImage2DList;
VulkanImageViewList &vkImage2DViewList =
vkNonDedicatedImage2DViewList;
clCl2VkExternalSemaphore->signal(cmd_queue1);
if (!useSingleImageKernel)
{
for (size_t i2DIdx = 0;
i2DIdx < vkImage2DList.size(); i2DIdx++)
{
for (uint32_t mipLevel = 0;
mipLevel < numMipLevels; mipLevel++)
{
uint32_t i2DvIdx =
(uint32_t)(i2DIdx * numMipLevels)
+ mipLevel;
vkDescriptorSet.update(
1 + i2DvIdx,
vkImage2DViewList[i2DvIdx]);
}
}
vkDescriptorSet.updateArray(1,
vkImage2DViewList);
vkCopyCommandBuffer.begin();
vkCopyCommandBuffer.pipelineBarrier(
vkImage2DList,
@@ -743,29 +708,25 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
}
for (int i = 0; i < num2DImages; i++)
{
delete vkNonDedicatedImage2DListDeviceMemory1
[i];
delete vkNonDedicatedImage2DListDeviceMemory2
[i];
delete nonDedicatedExternalMemory1[i];
delete nonDedicatedExternalMemory2[i];
delete vkImage2DListDeviceMemory1[i];
delete vkImage2DListDeviceMemory2[i];
delete externalMemory1[i];
delete externalMemory2[i];
}
vkNonDedicatedImage2DListDeviceMemory1.erase(
vkNonDedicatedImage2DListDeviceMemory1.begin(),
vkNonDedicatedImage2DListDeviceMemory1.begin()
vkImage2DListDeviceMemory1.erase(
vkImage2DListDeviceMemory1.begin(),
vkImage2DListDeviceMemory1.begin()
+ num2DImages);
vkNonDedicatedImage2DListDeviceMemory2.erase(
vkNonDedicatedImage2DListDeviceMemory2.begin(),
vkNonDedicatedImage2DListDeviceMemory2.begin()
+ num2DImages);
nonDedicatedExternalMemory1.erase(
nonDedicatedExternalMemory1.begin(),
nonDedicatedExternalMemory1.begin()
+ num2DImages);
nonDedicatedExternalMemory2.erase(
nonDedicatedExternalMemory2.begin(),
nonDedicatedExternalMemory2.begin()
vkImage2DListDeviceMemory2.erase(
vkImage2DListDeviceMemory2.begin(),
vkImage2DListDeviceMemory2.begin()
+ num2DImages);
externalMemory1.erase(externalMemory1.begin(),
externalMemory1.begin()
+ num2DImages);
externalMemory2.erase(externalMemory2.begin(),
externalMemory2.begin()
+ num2DImages);
if (CL_SUCCESS != err)
{
goto CLEANUP;
@@ -822,9 +783,11 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
srcBufferPtr = (char *)malloc(maxImage2DSize);
dstBufferPtr = (char *)malloc(maxImage2DSize);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList(
VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1,
VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_2D_IMAGE_DESCRIPTORS);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
vkDescriptorSetLayoutBindingList.addBinding(
0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_2D_IMAGE_DESCRIPTORS);
VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout);
@@ -851,10 +814,10 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
clCl2VkExternalSemaphore = new clExternalSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
std::vector<VulkanDeviceMemory *> vkNonDedicatedImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkNonDedicatedImage2DListDeviceMemory2;
std::vector<clExternalMemoryImage *> nonDedicatedExternalMemory1;
std::vector<clExternalMemoryImage *> nonDedicatedExternalMemory2;
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2;
std::vector<clExternalMemoryImage *> externalMemory1;
std::vector<clExternalMemoryImage *> externalMemory2;
std::vector<char> vkImage2DShader;
for (size_t fIdx = 0; fIdx < vkFormatList.size(); fIdx++)
@@ -957,9 +920,18 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
// Skip running for WIN32 NT handle.
continue;
}
VulkanImageTiling vulkanImageTiling =
vkClExternalMemoryHandleTilingAssumption(
deviceId,
vkExternalMemoryHandleTypeList[emhtIdx], &err);
ASSERT_SUCCESS(err,
"Failed to query OpenCL tiling mode");
VulkanImage2D vkDummyImage2D(
vkDevice, vkFormatList[0], widthList[0],
heightList[0], 1, vkExternalMemoryHandleType);
heightList[0], vulkanImageTiling, 1,
vkExternalMemoryHandleType);
const VulkanMemoryTypeList &memoryTypeList =
vkDummyImage2D.getMemoryTypeList();
@@ -985,98 +957,78 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
{
VulkanImage2D vkImage2D(
vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType);
vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
ASSERT_LEQ(vkImage2D.getSize(), maxImage2DSize);
totalImageMemSize =
ROUND_UP(vkImage2D.getSize(),
vkImage2D.getAlignment());
}
VulkanImage2DList vkNonDedicatedImage2DList(
VulkanImage2DList vkImage2DList(
num2DImages, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType);
for (size_t bIdx = 0;
bIdx < vkNonDedicatedImage2DList.size();
vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
for (size_t bIdx = 0; bIdx < vkImage2DList.size();
bIdx++)
{
// Create list of Vulkan device memories and
// bind the list of Vulkan images.
vkNonDedicatedImage2DListDeviceMemory1
.push_back(new VulkanDeviceMemory(
vkDevice, totalImageMemSize, memoryType,
vkImage2DListDeviceMemory1.push_back(
new VulkanDeviceMemory(
vkDevice, vkImage2DList[bIdx],
memoryType,
vkExternalMemoryHandleType));
vkNonDedicatedImage2DListDeviceMemory1[bIdx]
->bindImage(vkNonDedicatedImage2DList[bIdx],
0);
nonDedicatedExternalMemory1.push_back(
vkImage2DListDeviceMemory1[bIdx]->bindImage(
vkImage2DList[bIdx], 0);
externalMemory1.push_back(
new clExternalMemoryImage(
*vkNonDedicatedImage2DListDeviceMemory1
[bIdx],
*vkImage2DListDeviceMemory1[bIdx],
vkExternalMemoryHandleType, context,
totalImageMemSize, width, height, 0,
vkNonDedicatedImage2DList[bIdx],
deviceId));
vkImage2DList[bIdx], deviceId));
}
VulkanImageViewList vkNonDedicatedImage2DViewList(
vkDevice, vkNonDedicatedImage2DList);
VulkanImageViewList vkImage2DViewList(
vkDevice, vkImage2DList);
VulkanImage2DList vkNonDedicatedImage2DList2(
VulkanImage2DList vkImage2DList2(
num2DImages, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType);
for (size_t bIdx = 0;
bIdx < vkNonDedicatedImage2DList2.size();
vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
for (size_t bIdx = 0; bIdx < vkImage2DList2.size();
bIdx++)
{
vkNonDedicatedImage2DListDeviceMemory2
.push_back(new VulkanDeviceMemory(
vkDevice, totalImageMemSize, memoryType,
vkImage2DListDeviceMemory2.push_back(
new VulkanDeviceMemory(
vkDevice, vkImage2DList2[bIdx],
memoryType,
vkExternalMemoryHandleType));
vkNonDedicatedImage2DListDeviceMemory2[bIdx]
->bindImage(
vkNonDedicatedImage2DList2[bIdx], 0);
nonDedicatedExternalMemory2.push_back(
vkImage2DListDeviceMemory2[bIdx]->bindImage(
vkImage2DList2[bIdx], 0);
externalMemory2.push_back(
new clExternalMemoryImage(
*vkNonDedicatedImage2DListDeviceMemory2
[bIdx],
*vkImage2DListDeviceMemory2[bIdx],
vkExternalMemoryHandleType, context,
totalImageMemSize, width, height, 0,
vkNonDedicatedImage2DList2[bIdx],
deviceId));
vkImage2DList2[bIdx], deviceId));
}
VulkanImageViewList vkDedicatedImage2DViewList(
vkDevice, vkNonDedicatedImage2DList2);
cl_mem external_mem_image1[4];
cl_mem external_mem_image2[4];
for (int i = 0; i < num2DImages; i++)
{
external_mem_image1[i] =
nonDedicatedExternalMemory1[i]
externalMemory1[i]
->getExternalMemoryImage();
external_mem_image2[i] =
nonDedicatedExternalMemory2[i]
externalMemory2[i]
->getExternalMemoryImage();
}
VulkanImage2DList &vkImage2DList =
vkNonDedicatedImage2DList;
VulkanImageViewList &vkImage2DViewList =
vkNonDedicatedImage2DViewList;
clCl2VkExternalSemaphore->signal(cmd_queue1);
if (!useSingleImageKernel)
{
for (size_t i2DIdx = 0;
i2DIdx < vkImage2DList.size(); i2DIdx++)
{
for (uint32_t mipLevel = 0;
mipLevel < numMipLevels; mipLevel++)
{
uint32_t i2DvIdx =
(uint32_t)(i2DIdx * numMipLevels)
+ mipLevel;
vkDescriptorSet.update(
1 + i2DvIdx,
vkImage2DViewList[i2DvIdx]);
}
}
vkDescriptorSet.updateArray(1,
vkImage2DViewList);
vkCopyCommandBuffer.begin();
vkCopyCommandBuffer.pipelineBarrier(
vkImage2DList,
@@ -1275,29 +1227,25 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
}
for (int i = 0; i < num2DImages; i++)
{
delete vkNonDedicatedImage2DListDeviceMemory1
[i];
delete vkNonDedicatedImage2DListDeviceMemory2
[i];
delete nonDedicatedExternalMemory1[i];
delete nonDedicatedExternalMemory2[i];
delete vkImage2DListDeviceMemory1[i];
delete vkImage2DListDeviceMemory2[i];
delete externalMemory1[i];
delete externalMemory2[i];
}
vkNonDedicatedImage2DListDeviceMemory1.erase(
vkNonDedicatedImage2DListDeviceMemory1.begin(),
vkNonDedicatedImage2DListDeviceMemory1.begin()
vkImage2DListDeviceMemory1.erase(
vkImage2DListDeviceMemory1.begin(),
vkImage2DListDeviceMemory1.begin()
+ num2DImages);
vkNonDedicatedImage2DListDeviceMemory2.erase(
vkNonDedicatedImage2DListDeviceMemory2.begin(),
vkNonDedicatedImage2DListDeviceMemory2.begin()
+ num2DImages);
nonDedicatedExternalMemory1.erase(
nonDedicatedExternalMemory1.begin(),
nonDedicatedExternalMemory1.begin()
+ num2DImages);
nonDedicatedExternalMemory2.erase(
nonDedicatedExternalMemory2.begin(),
nonDedicatedExternalMemory2.begin()
vkImage2DListDeviceMemory2.erase(
vkImage2DListDeviceMemory2.begin(),
vkImage2DListDeviceMemory2.begin()
+ num2DImages);
externalMemory1.erase(externalMemory1.begin(),
externalMemory1.begin()
+ num2DImages);
externalMemory2.erase(externalMemory2.begin(),
externalMemory2.begin()
+ num2DImages);
if (CL_SUCCESS != err)
{
goto CLEANUP;

1
test_conformance/vulkan/vulkan_interop_common.hpp
View File

@@ -45,6 +45,5 @@ extern bool useDeviceLocal;
extern bool disableNTHandleType;
// Enable offset for multiImport of vulkan device memory
extern bool enableOffset;
extern bool non_dedicated;
#endif // _vulkan_interop_common_hpp_