ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-25 08: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

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

@@ -19,7 +19,7 @@
#include "harness/errorHelpers.h" #include "harness/errorHelpers.h"
#include "harness/deviceInfo.h" #include "harness/deviceInfo.h"
#include <assert.h> #include <assert.h>
#include <iostream> #include <algorithm>
#include <stdexcept> #include <stdexcept>
#define ASSERT(x) assert((x)) #define ASSERT(x) assert((x))
@@ -887,3 +887,67 @@ cl_semaphore_khr &clExternalSemaphore::getCLSemaphore()
{ {
return m_externalSemaphore; 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); 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_ #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(vkDestroyImageView) \
VK_FUNC_DECL(vkCreateImage) \ VK_FUNC_DECL(vkCreateImage) \
VK_FUNC_DECL(vkGetImageMemoryRequirements) \ VK_FUNC_DECL(vkGetImageMemoryRequirements) \
VK_FUNC_DECL(vkGetImageMemoryRequirements2) \
VK_FUNC_DECL(vkDestroyImage) \ VK_FUNC_DECL(vkDestroyImage) \
VK_FUNC_DECL(vkDestroyBuffer) \ VK_FUNC_DECL(vkDestroyBuffer) \
VK_FUNC_DECL(vkDestroyPipeline) \ VK_FUNC_DECL(vkDestroyPipeline) \
@@ -87,8 +88,9 @@
VK_FUNC_DECL(vkDestroyDescriptorSetLayout) \ VK_FUNC_DECL(vkDestroyDescriptorSetLayout) \
VK_FUNC_DECL(vkGetPhysicalDeviceQueueFamilyProperties) \ VK_FUNC_DECL(vkGetPhysicalDeviceQueueFamilyProperties) \
VK_FUNC_DECL(vkGetPhysicalDeviceFeatures) \ VK_FUNC_DECL(vkGetPhysicalDeviceFeatures) \
VK_FUNC_DECL(vkGetPhysicalDeviceProperties2KHR) \ VK_FUNC_DECL(vkGetPhysicalDeviceProperties2) \
VK_FUNC_DECL(vkGetBufferMemoryRequirements) \ VK_FUNC_DECL(vkGetBufferMemoryRequirements) \
VK_FUNC_DECL(vkGetBufferMemoryRequirements2) \
VK_FUNC_DECL(vkGetMemoryFdKHR) \ VK_FUNC_DECL(vkGetMemoryFdKHR) \
VK_FUNC_DECL(vkGetSemaphoreFdKHR) \ VK_FUNC_DECL(vkGetSemaphoreFdKHR) \
VK_FUNC_DECL(vkEnumeratePhysicalDeviceGroups) \ VK_FUNC_DECL(vkEnumeratePhysicalDeviceGroups) \
@@ -160,6 +162,7 @@
#define vkDestroyImageView _vkDestroyImageView #define vkDestroyImageView _vkDestroyImageView
#define vkCreateImage _vkCreateImage #define vkCreateImage _vkCreateImage
#define vkGetImageMemoryRequirements _vkGetImageMemoryRequirements #define vkGetImageMemoryRequirements _vkGetImageMemoryRequirements
#define vkGetImageMemoryRequirements2 _vkGetImageMemoryRequirements2
#define vkDestroyImage _vkDestroyImage #define vkDestroyImage _vkDestroyImage
#define vkDestroyBuffer _vkDestroyBuffer #define vkDestroyBuffer _vkDestroyBuffer
#define vkDestroyPipeline _vkDestroyPipeline #define vkDestroyPipeline _vkDestroyPipeline
@@ -173,8 +176,9 @@
#define vkGetPhysicalDeviceQueueFamilyProperties \ #define vkGetPhysicalDeviceQueueFamilyProperties \
_vkGetPhysicalDeviceQueueFamilyProperties _vkGetPhysicalDeviceQueueFamilyProperties
#define vkGetPhysicalDeviceFeatures _vkGetPhysicalDeviceFeatures #define vkGetPhysicalDeviceFeatures _vkGetPhysicalDeviceFeatures
#define vkGetPhysicalDeviceProperties2KHR _vkGetPhysicalDeviceProperties2KHR #define vkGetPhysicalDeviceProperties2 _vkGetPhysicalDeviceProperties2
#define vkGetBufferMemoryRequirements _vkGetBufferMemoryRequirements #define vkGetBufferMemoryRequirements _vkGetBufferMemoryRequirements
#define vkGetBufferMemoryRequirements2 _vkGetBufferMemoryRequirements2
#define vkGetMemoryFdKHR _vkGetMemoryFdKHR #define vkGetMemoryFdKHR _vkGetMemoryFdKHR
#define vkGetSemaphoreFdKHR _vkGetSemaphoreFdKHR #define vkGetSemaphoreFdKHR _vkGetSemaphoreFdKHR
#define vkEnumeratePhysicalDeviceGroups _vkEnumeratePhysicalDeviceGroups #define vkEnumeratePhysicalDeviceGroups _vkEnumeratePhysicalDeviceGroups

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

@@ -141,6 +141,16 @@ VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
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( VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
size_t numDescriptorSetLayoutBindings, VulkanDescriptorType descriptorType, size_t numDescriptorSetLayoutBindings, VulkanDescriptorType descriptorType,
uint32_t descriptorCount, VulkanShaderStage shaderStage) uint32_t descriptorCount, VulkanShaderStage shaderStage)
@@ -268,6 +278,7 @@ VulkanImage2DList::VulkanImage2DList(
size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory, size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory,
uint64_t baseOffset, uint64_t interImageOffset, const VulkanDevice &device, uint64_t baseOffset, uint64_t interImageOffset, const VulkanDevice &device,
VulkanFormat format, uint32_t width, uint32_t height, uint32_t mipLevels, VulkanFormat format, uint32_t width, uint32_t height, uint32_t mipLevels,
VulkanImageTiling vulkanImageTiling,
VulkanExternalMemoryHandleType externalMemoryHandleType, VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage, VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
VulkanSharingMode sharingMode) VulkanSharingMode sharingMode)
@@ -275,8 +286,8 @@ VulkanImage2DList::VulkanImage2DList(
for (size_t i2DIdx = 0; i2DIdx < numImages; i2DIdx++) for (size_t i2DIdx = 0; i2DIdx < numImages; i2DIdx++)
{ {
VulkanImage2D *image2D = new VulkanImage2D( VulkanImage2D *image2D = new VulkanImage2D(
device, format, width, height, mipLevels, externalMemoryHandleType, device, format, width, height, vulkanImageTiling, mipLevels,
imageCreateFlag, imageUsage, sharingMode); externalMemoryHandleType, imageCreateFlag, imageUsage, sharingMode);
add(*image2D); add(*image2D);
deviceMemory[i2DIdx]->bindImage( deviceMemory[i2DIdx]->bindImage(
*image2D, baseOffset + (i2DIdx * interImageOffset)); *image2D, baseOffset + (i2DIdx * interImageOffset));
@@ -285,16 +296,16 @@ VulkanImage2DList::VulkanImage2DList(
VulkanImage2DList::VulkanImage2DList( VulkanImage2DList::VulkanImage2DList(
size_t numImages, const VulkanDevice &device, VulkanFormat format, size_t numImages, const VulkanDevice &device, VulkanFormat format,
uint32_t width, uint32_t height, uint32_t mipLevels, uint32_t width, uint32_t height, VulkanImageTiling vulkanImageTiling,
VulkanExternalMemoryHandleType externalMemoryHandleType, uint32_t mipLevels, VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage, VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
VulkanSharingMode sharingMode) VulkanSharingMode sharingMode)
{ {
for (size_t bIdx = 0; bIdx < numImages; bIdx++) for (size_t bIdx = 0; bIdx < numImages; bIdx++)
{ {
VulkanImage2D *image2D = new VulkanImage2D( VulkanImage2D *image2D = new VulkanImage2D(
device, format, width, height, mipLevels, externalMemoryHandleType, device, format, width, height, vulkanImageTiling, mipLevels,
imageCreateFlag, imageUsage, sharingMode); externalMemoryHandleType, imageCreateFlag, imageUsage, sharingMode);
add(*image2D); 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 descriptorType0, uint32_t descriptorCount0,
VulkanDescriptorType descriptorType1, uint32_t descriptorCount1, VulkanDescriptorType descriptorType1, uint32_t descriptorCount1,
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE); VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
void
addBinding(size_t binding, VulkanDescriptorType descriptorType,
uint32_t descriptorCount,
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
virtual ~VulkanDescriptorSetLayoutBindingList(); virtual ~VulkanDescriptorSetLayoutBindingList();
}; };
@@ -208,6 +212,7 @@ public:
uint64_t baseOffset, uint64_t interImageOffset, uint64_t baseOffset, uint64_t interImageOffset,
const VulkanDevice &device, VulkanFormat format, uint32_t width, const VulkanDevice &device, VulkanFormat format, uint32_t width,
uint32_t height, uint32_t mipLevels, uint32_t height, uint32_t mipLevels,
VulkanImageTiling vulkanImageTiling,
VulkanExternalMemoryHandleType externalMemoryHandleType = VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE, VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE, VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
@@ -216,7 +221,8 @@ public:
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE); VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
VulkanImage2DList( VulkanImage2DList(
size_t numImages, const VulkanDevice &device, VulkanFormat format, 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 = VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE, VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_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 <fstream>
#include <set> #include <set>
#include <string> #include <string>
#include <algorithm>
#include <CL/cl.h> #include <CL/cl.h>
#include <CL/cl_ext.h> #include <CL/cl_ext.h>
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)

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

@@ -33,7 +33,8 @@
const VulkanInstance& getVulkanInstance(); const VulkanInstance& getVulkanInstance();
const VulkanPhysicalDevice& getVulkanPhysicalDevice(); const VulkanPhysicalDevice& getVulkanPhysicalDevice();
const VulkanQueueFamily& 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& const VulkanMemoryType&
getVulkanMemoryType(const VulkanDevice& device, getVulkanMemoryType(const VulkanDevice& device,
VulkanMemoryTypeProperty memoryTypeProperty); 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"; const char *vulkanLoaderLibraryName = "vulkan-1.dll";
#elif defined(__ANDROID__) #elif defined(__ANDROID__)
const char *vulkanLoaderLibraryName = "libvulkan.so"; const char *vulkanLoaderLibraryName = "libvulkan.so";
#elif defined(__linux__) #else
const char *vulkanLoaderLibraryName = "libvulkan.so.1"; const char *vulkanLoaderLibraryName = "libvulkan.so.1";
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
@@ -276,13 +276,13 @@ VulkanPhysicalDevice::VulkanPhysicalDevice(VkPhysicalDevice vkPhysicalDevice)
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR; VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR;
vkPhysicalDeviceIDPropertiesKHR.pNext = NULL; vkPhysicalDeviceIDPropertiesKHR.pNext = NULL;
VkPhysicalDeviceProperties2KHR vkPhysicalDeviceProperties2KHR = {}; VkPhysicalDeviceProperties2 vkPhysicalDeviceProperties2 = {};
vkPhysicalDeviceProperties2KHR.sType = vkPhysicalDeviceProperties2.sType =
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR; VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
vkPhysicalDeviceProperties2KHR.pNext = &vkPhysicalDeviceIDPropertiesKHR; vkPhysicalDeviceProperties2.pNext = &vkPhysicalDeviceIDPropertiesKHR;
vkGetPhysicalDeviceProperties2KHR(m_vkPhysicalDevice, vkGetPhysicalDeviceProperties2(m_vkPhysicalDevice,
&vkPhysicalDeviceProperties2KHR); &vkPhysicalDeviceProperties2);
memcpy(m_vkDeviceUUID, vkPhysicalDeviceIDPropertiesKHR.deviceUUID, memcpy(m_vkDeviceUUID, vkPhysicalDeviceIDPropertiesKHR.deviceUUID,
sizeof(m_vkDeviceUUID)); sizeof(m_vkDeviceUUID));
@@ -1013,12 +1013,14 @@ void VulkanDescriptorPool::VulkanDescriptorPoolCommon(
== vkDescriptorTypeToDescriptorCountMap.end()) == vkDescriptorTypeToDescriptorCountMap.end())
{ {
vkDescriptorTypeToDescriptorCountMap vkDescriptorTypeToDescriptorCountMap
[vkDescriptorSetLayoutBinding.descriptorType] = 1; [vkDescriptorSetLayoutBinding.descriptorType] =
vkDescriptorSetLayoutBinding.descriptorCount;
} }
else else
{ {
vkDescriptorTypeToDescriptorCountMap 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); 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, void VulkanDescriptorSet::update(uint32_t binding,
const VulkanImageView &imageView) const VulkanImageView &imageView)
{ {
@@ -1182,6 +1213,34 @@ void VulkanDescriptorSet::update(uint32_t binding,
vkUpdateDescriptorSets(m_device, 1, &vkWriteDescriptorSet, 0, NULL); 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 VulkanDescriptorSet::operator VkDescriptorSet() const
{ {
return m_vkDescriptorSet; return m_vkDescriptorSet;
@@ -1505,12 +1564,14 @@ VulkanBuffer::VulkanBuffer(const VulkanBuffer &buffer)
m_memoryTypeList(buffer.m_memoryTypeList) m_memoryTypeList(buffer.m_memoryTypeList)
{} {}
bool VulkanBuffer::isDedicated() const { return m_dedicated; }
VulkanBuffer::VulkanBuffer( VulkanBuffer::VulkanBuffer(
const VulkanDevice &device, uint64_t size, const VulkanDevice &device, uint64_t size,
VulkanExternalMemoryHandleType externalMemoryHandleType, VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanBufferUsage bufferUsage, VulkanSharingMode sharingMode, VulkanBufferUsage bufferUsage, VulkanSharingMode sharingMode,
const VulkanQueueFamilyList &queueFamilyList) 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; std::vector<uint32_t> queueFamilyIndexList;
if (queueFamilyList.size() == 0) if (queueFamilyList.size() == 0)
@@ -1556,16 +1617,36 @@ VulkanBuffer::VulkanBuffer(
vkCreateBuffer(m_device, &vkBufferCreateInfo, NULL, &m_vkBuffer); vkCreateBuffer(m_device, &vkBufferCreateInfo, NULL, &m_vkBuffer);
VkMemoryRequirements vkMemoryRequirements = {}; VkMemoryDedicatedRequirements vkMemoryDedicatedRequirements = {};
vkGetBufferMemoryRequirements(m_device, m_vkBuffer, &vkMemoryRequirements); vkMemoryDedicatedRequirements.sType =
m_size = vkMemoryRequirements.size; VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
m_alignment = vkMemoryRequirements.alignment; 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 = const VulkanMemoryTypeList &memoryTypeList =
m_device.getPhysicalDevice().getMemoryTypeList(); m_device.getPhysicalDevice().getMemoryTypeList();
for (size_t mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++) for (size_t mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++)
{ {
uint32_t memoryTypeIndex = memoryTypeList[mtIdx]; uint32_t memoryTypeIndex = memoryTypeList[mtIdx];
if ((1 << memoryTypeIndex) & vkMemoryRequirements.memoryTypeBits) if ((1 << memoryTypeIndex)
& vkMemoryRequirements.memoryRequirements.memoryTypeBits)
{ {
m_memoryTypeList.add(memoryTypeList[mtIdx]); m_memoryTypeList.add(memoryTypeList[mtIdx]);
} }
@@ -1640,16 +1721,36 @@ VulkanImage::VulkanImage(
vkCreateImage(m_device, &vkImageCreateInfo, NULL, &m_vkImage); vkCreateImage(m_device, &vkImageCreateInfo, NULL, &m_vkImage);
VulkanImageCreateInfo = vkImageCreateInfo; VulkanImageCreateInfo = vkImageCreateInfo;
VkMemoryRequirements vkMemoryRequirements = {};
vkGetImageMemoryRequirements(m_device, m_vkImage, &vkMemoryRequirements); VkMemoryDedicatedRequirements vkMemoryDedicatedRequirements = {};
m_size = vkMemoryRequirements.size; vkMemoryDedicatedRequirements.sType =
m_alignment = vkMemoryRequirements.alignment; 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 = const VulkanMemoryTypeList &memoryTypeList =
m_device.getPhysicalDevice().getMemoryTypeList(); m_device.getPhysicalDevice().getMemoryTypeList();
for (size_t mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++) for (size_t mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++)
{ {
uint32_t memoryTypeIndex = memoryTypeList[mtIdx]; uint32_t memoryTypeIndex = memoryTypeList[mtIdx];
if ((1 << memoryTypeIndex) & vkMemoryRequirements.memoryTypeBits) if ((1 << memoryTypeIndex)
& vkMemoryRequirements.memoryRequirements.memoryTypeBits)
{ {
m_memoryTypeList.add(memoryTypeList[mtIdx]); 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; } uint64_t VulkanImage::getAlignment() const { return m_alignment; }
bool VulkanImage::isDedicated() const { return m_dedicated; }
const VulkanMemoryTypeList &VulkanImage::getMemoryTypeList() const const VulkanMemoryTypeList &VulkanImage::getMemoryTypeList() const
{ {
return m_memoryTypeList; return m_memoryTypeList;
@@ -1694,14 +1797,14 @@ VulkanImage2D::VulkanImage2D(const VulkanImage2D &image2D): VulkanImage(image2D)
VulkanImage2D::VulkanImage2D( VulkanImage2D::VulkanImage2D(
const VulkanDevice &device, VulkanFormat format, uint32_t width, const VulkanDevice &device, VulkanFormat format, uint32_t width,
uint32_t height, uint32_t numMipLevels, uint32_t height, VulkanImageTiling imageTiling, uint32_t numMipLevels,
VulkanExternalMemoryHandleType externalMemoryHandleType, VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage, VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
VulkanSharingMode sharingMode) VulkanSharingMode sharingMode)
: VulkanImage(device, VULKAN_IMAGE_TYPE_2D, format, : VulkanImage(device, VULKAN_IMAGE_TYPE_2D, format,
VulkanExtent3D(width, height, 1), numMipLevels, 1, VulkanExtent3D(width, height, 1), numMipLevels, 1,
externalMemoryHandleType, imageCreateFlag, externalMemoryHandleType, imageCreateFlag, imageTiling,
VULKAN_IMAGE_TILING_OPTIMAL, imageUsage, sharingMode) imageUsage, sharingMode)
{} {}
VulkanImage2D::~VulkanImage2D() {} VulkanImage2D::~VulkanImage2D() {}
@@ -1888,7 +1991,8 @@ VulkanDeviceMemory::VulkanDeviceMemory(
const VulkanDevice &device, const VulkanImage &image, const VulkanDevice &device, const VulkanImage &image,
const VulkanMemoryType &memoryType, const VulkanMemoryType &memoryType,
VulkanExternalMemoryHandleType externalMemoryHandleType, const void *name) 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) #if defined(_WIN32) || defined(_WIN64)
WindowsSecurityAttributes winSecurityAttributes; WindowsSecurityAttributes winSecurityAttributes;
@@ -1921,20 +2025,95 @@ VulkanDeviceMemory::VulkanDeviceMemory(
VkMemoryDedicatedAllocateInfo vkMemoryDedicatedAllocateInfo = {}; VkMemoryDedicatedAllocateInfo vkMemoryDedicatedAllocateInfo = {};
vkMemoryDedicatedAllocateInfo.sType = vkMemoryDedicatedAllocateInfo.sType =
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
vkMemoryDedicatedAllocateInfo.pNext = vkMemoryDedicatedAllocateInfo.pNext = NULL;
externalMemoryHandleType ? &vkExportMemoryAllocateInfoKHR : NULL;
vkMemoryDedicatedAllocateInfo.image = image; vkMemoryDedicatedAllocateInfo.image = image;
vkMemoryDedicatedAllocateInfo.buffer = VK_NULL_HANDLE; vkMemoryDedicatedAllocateInfo.buffer = VK_NULL_HANDLE;
VkMemoryAllocateInfo vkMemoryAllocateInfo = {}; VkMemoryAllocateInfo vkMemoryAllocateInfo = {};
vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
vkMemoryAllocateInfo.pNext = &vkMemoryDedicatedAllocateInfo;
vkMemoryAllocateInfo.allocationSize = m_size; vkMemoryAllocateInfo.allocationSize = m_size;
vkMemoryAllocateInfo.memoryTypeIndex = (uint32_t)memoryType; 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); 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() VulkanDeviceMemory::~VulkanDeviceMemory()
{ {
vkFreeMemory(m_device, m_vkDeviceMemory, NULL); 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) 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); vkBindBufferMemory(m_device, buffer, m_vkDeviceMemory, offset);
} }
void VulkanDeviceMemory::bindImage(const VulkanImage &image, uint64_t 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); 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); const VulkanDescriptorSetLayout &descriptorSetLayout);
virtual ~VulkanDescriptorSet(); virtual ~VulkanDescriptorSet();
void update(uint32_t binding, const VulkanBuffer &buffer); 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 update(uint32_t binding, const VulkanImageView &imageView);
void updateArray(uint32_t binding,
const VulkanImageViewList &imageViewList);
operator VkDescriptorSet() const; operator VkDescriptorSet() const;
}; };
@@ -424,6 +428,7 @@ protected:
VkBuffer m_vkBuffer; VkBuffer m_vkBuffer;
uint64_t m_size; uint64_t m_size;
uint64_t m_alignment; uint64_t m_alignment;
bool m_dedicated;
VulkanMemoryTypeList m_memoryTypeList; VulkanMemoryTypeList m_memoryTypeList;
VulkanBuffer(const VulkanBuffer &buffer); VulkanBuffer(const VulkanBuffer &buffer);
@@ -441,6 +446,7 @@ public:
uint64_t getSize() const; uint64_t getSize() const;
uint64_t getAlignment() const; uint64_t getAlignment() const;
const VulkanMemoryTypeList &getMemoryTypeList() const; const VulkanMemoryTypeList &getMemoryTypeList() const;
bool isDedicated() const;
operator VkBuffer() const; operator VkBuffer() const;
}; };
@@ -452,6 +458,7 @@ protected:
const VulkanFormat m_format; const VulkanFormat m_format;
const uint32_t m_numMipLevels; const uint32_t m_numMipLevels;
const uint32_t m_numLayers; const uint32_t m_numLayers;
bool m_dedicated;
VkImage m_vkImage; VkImage m_vkImage;
uint64_t m_size; uint64_t m_size;
uint64_t m_alignment; uint64_t m_alignment;
@@ -478,6 +485,7 @@ public:
uint32_t getNumLayers() const; uint32_t getNumLayers() const;
uint64_t getSize() const; uint64_t getSize() const;
uint64_t getAlignment() const; uint64_t getAlignment() const;
bool isDedicated() const;
const VulkanMemoryTypeList &getMemoryTypeList() const; const VulkanMemoryTypeList &getMemoryTypeList() const;
VkImageCreateInfo getVkImageCreateInfo() const; VkImageCreateInfo getVkImageCreateInfo() const;
operator VkImage() const; operator VkImage() const;
@@ -487,12 +495,11 @@ class VulkanImage2D : public VulkanImage {
protected: protected:
VkImageView m_vkImageView; VkImageView m_vkImageView;
VulkanImage2D(const VulkanImage2D &image2D);
public: public:
VulkanImage2D( VulkanImage2D(
const VulkanDevice &device, VulkanFormat format, uint32_t width, 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 = VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE, VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE, VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
@@ -501,6 +508,8 @@ public:
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE); VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
virtual ~VulkanImage2D(); virtual ~VulkanImage2D();
virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const; virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const;
VulkanImage2D(const VulkanImage2D &image2D);
}; };
class VulkanImageView { class VulkanImageView {
@@ -541,6 +550,11 @@ public:
VulkanExternalMemoryHandleType externalMemoryHandleType = VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE, VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
const void *name = NULL); 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(); virtual ~VulkanDeviceMemory();
uint64_t getSize() const; uint64_t getSize() const;
#ifdef _WIN32 #ifdef _WIN32

5
test_conformance/vulkan/main.cpp
View File

@@ -185,7 +185,6 @@ bool useSingleImageKernel = false;
bool useDeviceLocal = false; bool useDeviceLocal = false;
bool disableNTHandleType = false; bool disableNTHandleType = false;
bool enableOffset = false; bool enableOffset = false;
bool non_dedicated = false;
static void printUsage(const char *execName) static void printUsage(const char *execName)
{ {
@@ -232,10 +231,6 @@ size_t parseParams(int argc, const char *argv[], const char **argList)
{ {
enableOffset = true; enableOffset = true;
} }
if (!strcmp(argv[i], "--non_dedicated"))
{
non_dedicated = true;
}
if (strcmp(argv[i], "-h") == 0) if (strcmp(argv[i], "-h") == 0)
{ {
printUsage(argv[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 = const VulkanMemoryTypeList& memoryTypeList =
vkDummyBuffer.getMemoryTypeList(); vkDummyBuffer.getMemoryTypeList();
VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(
vkDevice, bufferSize, memoryTypeList[0], vkExternalMemoryHandleType);
VulkanBufferList vkBufferList(1, vkDevice, bufferSize, VulkanBufferList vkBufferList(1, vkDevice, bufferSize,
vkExternalMemoryHandleType); vkExternalMemoryHandleType);
VulkanDeviceMemory* vkDeviceMem =
new VulkanDeviceMemory(vkDevice, vkBufferList[0], memoryTypeList[0],
vkExternalMemoryHandleType);
vkDeviceMem->bindBuffer(vkBufferList[0], 0); vkDeviceMem->bindBuffer(vkBufferList[0], 0);
@@ -231,22 +232,27 @@ int test_consistency_external_image(cl_device_id deviceID, cl_context _context,
VulkanExternalMemoryHandleType vkExternalMemoryHandleType = VulkanExternalMemoryHandleType vkExternalMemoryHandleType =
getSupportedVulkanExternalMemoryHandleTypeList()[0]; getSupportedVulkanExternalMemoryHandleTypeList()[0];
VulkanImage2D* vkImage2D =
new VulkanImage2D(vkDevice, VULKAN_FORMAT_R8G8B8A8_UNORM, width, height,
1, vkExternalMemoryHandleType);
const VulkanMemoryTypeList& memoryTypeList = vkImage2D->getMemoryTypeList(); VulkanImageTiling vulkanImageTiling =
uint64_t totalImageMemSize = vkImage2D->getSize(); 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 index: %lu\n", (uint32_t)memoryTypeList[0]);
log_info("Memory type property: %d\n", log_info("Memory type property: %d\n",
memoryTypeList[0].getMemoryTypeProperty()); memoryTypeList[0].getMemoryTypeProperty());
log_info("Image size : %d\n", totalImageMemSize); log_info("Image size : %d\n", totalImageMemSize);
VulkanDeviceMemory* vkDeviceMem = VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(
new VulkanDeviceMemory(vkDevice, totalImageMemSize, memoryTypeList[0], vkDevice, vkImage2D, memoryTypeList[0], vkExternalMemoryHandleType);
vkExternalMemoryHandleType); vkDeviceMem->bindImage(vkImage2D, 0);
vkDeviceMem->bindImage(*vkImage2D, 0);
void* handle = NULL; void* handle = NULL;
int fd; int fd;
@@ -299,7 +305,7 @@ int test_consistency_external_image(cl_device_id deviceID, cl_context _context,
extMemProperties.push_back(0); extMemProperties.push_back(0);
const VkImageCreateInfo VulkanImageCreateInfo = const VkImageCreateInfo VulkanImageCreateInfo =
vkImage2D->getVkImageCreateInfo(); vkImage2D.getVkImageCreateInfo();
errNum = getCLImageInfoFromVkImageInfo( errNum = getCLImageInfoFromVkImageInfo(
&VulkanImageCreateInfo, totalImageMemSize, &img_format, &image_desc); &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"); std::vector<char> vkBufferShader = readFile("buffer.spv");
VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader); VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList( VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
MAX_BUFFERS + 1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER); vkDescriptorSetLayoutBindingList.addBinding(
0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_BUFFERS);
VulkanDescriptorSetLayout vkDescriptorSetLayout( VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList); vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout); 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++) for (size_t bIdx = 0; bIdx < numBuffers; bIdx++)
{ {
vkBufferListDeviceMemory.push_back( vkBufferListDeviceMemory.push_back(new VulkanDeviceMemory(
new VulkanDeviceMemory(vkDevice, bufferSize, memoryType, vkDevice, vkBufferList[bIdx], memoryType,
vkExternalMemoryHandleType)); vkExternalMemoryHandleType));
externalMemory.push_back(new clExternalMemory( externalMemory.push_back(new clExternalMemory(
vkBufferListDeviceMemory[bIdx], vkExternalMemoryHandleType, vkBufferListDeviceMemory[bIdx], vkExternalMemoryHandleType,
0, bufferSize, context, deviceId)); 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], vkBufferListDeviceMemory[bIdx]->bindBuffer(vkBufferList[bIdx],
0); 0);
buffers[bIdx] = externalMemory[bIdx]->getExternalMemoryBuffer(); buffers[bIdx] = externalMemory[bIdx]->getExternalMemoryBuffer();
vkDescriptorSet.update((uint32_t)bIdx + 1, vkBufferList[bIdx]);
} }
vkDescriptorSet.updateArray(1, numBuffers, vkBufferList);
vkCommandBuffer.begin(); vkCommandBuffer.begin();
vkCommandBuffer.bindPipeline(vkComputePipeline); vkCommandBuffer.bindPipeline(vkComputePipeline);
vkCommandBuffer.bindDescriptorSets( 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"); std::vector<char> vkBufferShader = readFile("buffer.spv");
VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader); VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList( VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
MAX_BUFFERS + 1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER); vkDescriptorSetLayoutBindingList.addBinding(
0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_BUFFERS);
VulkanDescriptorSetLayout vkDescriptorSetLayout( VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList); vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout); 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++) for (size_t bIdx = 0; bIdx < numBuffers; bIdx++)
{ {
vkBufferListDeviceMemory.push_back( vkBufferListDeviceMemory.push_back(new VulkanDeviceMemory(
new VulkanDeviceMemory(vkDevice, bufferSize, memoryType, vkDevice, vkBufferList[bIdx], memoryType,
vkExternalMemoryHandleType)); vkExternalMemoryHandleType));
externalMemory.push_back(new clExternalMemory( externalMemory.push_back(new clExternalMemory(
vkBufferListDeviceMemory[bIdx], vkExternalMemoryHandleType, vkBufferListDeviceMemory[bIdx], vkExternalMemoryHandleType,
0, bufferSize, context, deviceId)); 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], vkBufferListDeviceMemory[bIdx]->bindBuffer(vkBufferList[bIdx],
0); 0);
buffers[bIdx] = externalMemory[bIdx]->getExternalMemoryBuffer(); buffers[bIdx] = externalMemory[bIdx]->getExternalMemoryBuffer();
vkDescriptorSet.update((uint32_t)bIdx + 1, vkBufferList[bIdx]);
} }
vkDescriptorSet.updateArray(1, vkBufferList.size(), vkBufferList);
vkCommandBuffer.begin(); vkCommandBuffer.begin();
vkCommandBuffer.bindPipeline(vkComputePipeline); vkCommandBuffer.bindPipeline(vkComputePipeline);
vkCommandBuffer.bindDescriptorSets( vkCommandBuffer.bindDescriptorSets(
@@ -754,8 +761,11 @@ int run_test_with_multi_import_same_ctx(
std::vector<char> vkBufferShader = readFile("buffer.spv"); std::vector<char> vkBufferShader = readFile("buffer.spv");
VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader); VulkanShaderModule vkBufferShaderModule(vkDevice, vkBufferShader);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList( VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
MAX_BUFFERS + 1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER); vkDescriptorSetLayoutBindingList.addBinding(
0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_BUFFERS);
VulkanDescriptorSetLayout vkDescriptorSetLayout( VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList); vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout); VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout);
@@ -836,7 +846,7 @@ int run_test_with_multi_import_same_ctx(
if (withOffset == 0) if (withOffset == 0)
{ {
vkBufferListDeviceMemory.push_back( vkBufferListDeviceMemory.push_back(
new VulkanDeviceMemory(vkDevice, pBufferSize, new VulkanDeviceMemory(vkDevice, vkBufferList[bIdx],
memoryType, memoryType,
vkExternalMemoryHandleType)); vkExternalMemoryHandleType));
} }
@@ -880,9 +890,8 @@ int run_test_with_multi_import_same_ctx(
externalMemory[bIdx][cl_bIdx] externalMemory[bIdx][cl_bIdx]
->getExternalMemoryBuffer(); ->getExternalMemoryBuffer();
} }
vkDescriptorSet.update((uint32_t)bIdx + 1,
vkBufferList[bIdx]);
} }
vkDescriptorSet.updateArray(1, numBuffers, vkBufferList);
vkCommandBuffer.begin(); vkCommandBuffer.begin();
vkCommandBuffer.bindPipeline(vkComputePipeline); vkCommandBuffer.bindPipeline(vkComputePipeline);
vkCommandBuffer.bindDescriptorSets( 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); srcBufferPtr = (char *)malloc(maxImage2DSize);
dstBufferPtr = (char *)malloc(maxImage2DSize); dstBufferPtr = (char *)malloc(maxImage2DSize);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList( VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, vkDescriptorSetLayoutBindingList.addBinding(
VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_2D_IMAGE_DESCRIPTORS); 0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_2D_IMAGE_DESCRIPTORS);
VulkanDescriptorSetLayout vkDescriptorSetLayout( VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList); vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout); 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( clCl2VkExternalSemaphore = new clExternalSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId); vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
std::vector<VulkanDeviceMemory *> vkNonDedicatedImage2DListDeviceMemory1; std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkNonDedicatedImage2DListDeviceMemory2; std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2;
std::vector<clExternalMemoryImage *> nonDedicatedExternalMemory1; std::vector<clExternalMemoryImage *> externalMemory1;
std::vector<clExternalMemoryImage *> nonDedicatedExternalMemory2; std::vector<clExternalMemoryImage *> externalMemory2;
std::vector<char> vkImage2DShader; std::vector<char> vkImage2DShader;
for (size_t fIdx = 0; fIdx < vkFormatList.size(); fIdx++) 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 VulkanExternalMemoryHandleType
vkExternalMemoryHandleType = vkExternalMemoryHandleType =
vkExternalMemoryHandleTypeList[emhtIdx]; vkExternalMemoryHandleTypeList[emhtIdx];
log_info("External memory handle type: %d \n",
vkExternalMemoryHandleType);
if ((true == disableNTHandleType) if ((true == disableNTHandleType)
&& (VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT && (VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT
== vkExternalMemoryHandleType)) == 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. // Skip running for WIN32 NT handle.
continue; 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( VulkanImage2D vkDummyImage2D(
vkDevice, vkFormatList[0], widthList[0], vkDevice, vkFormatList[0], widthList[0],
heightList[0], 1, vkExternalMemoryHandleType); heightList[0], vulkanImageTiling, 1,
vkExternalMemoryHandleType);
const VulkanMemoryTypeList &memoryTypeList = const VulkanMemoryTypeList &memoryTypeList =
vkDummyImage2D.getMemoryTypeList(); vkDummyImage2D.getMemoryTypeList();
@@ -390,118 +400,73 @@ int run_test_with_two_queue(cl_context &context, cl_command_queue &cmd_queue1,
{ {
VulkanImage2D vkImage2D( VulkanImage2D vkImage2D(
vkDevice, vkFormat, width, height, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType); vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
ASSERT_LEQ(vkImage2D.getSize(), maxImage2DSize); ASSERT_LEQ(vkImage2D.getSize(), maxImage2DSize);
totalImageMemSize = totalImageMemSize =
ROUND_UP(vkImage2D.getSize(), ROUND_UP(vkImage2D.getSize(),
vkImage2D.getAlignment()); vkImage2D.getAlignment());
} }
VulkanImage2DList vkNonDedicatedImage2DList( VulkanImage2DList vkImage2DList(
num2DImages, vkDevice, vkFormat, width, height, num2DImages, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType); vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
for (size_t bIdx = 0; bIdx < num2DImages; bIdx++) for (size_t bIdx = 0; bIdx < num2DImages; bIdx++)
{ {
if (non_dedicated) vkImage2DListDeviceMemory1.push_back(
{ new VulkanDeviceMemory(
vkNonDedicatedImage2DListDeviceMemory1 vkDevice, vkImage2DList[bIdx],
.push_back(new VulkanDeviceMemory( memoryType,
vkDevice, totalImageMemSize, vkExternalMemoryHandleType));
memoryType, vkImage2DListDeviceMemory1[bIdx]->bindImage(
vkExternalMemoryHandleType)); vkImage2DList[bIdx], 0);
} externalMemory1.push_back(
else
{
vkNonDedicatedImage2DListDeviceMemory1
.push_back(new VulkanDeviceMemory(
vkDevice,
vkNonDedicatedImage2DList[bIdx],
memoryType,
vkExternalMemoryHandleType));
}
vkNonDedicatedImage2DListDeviceMemory1[bIdx]
->bindImage(vkNonDedicatedImage2DList[bIdx],
0);
nonDedicatedExternalMemory1.push_back(
new clExternalMemoryImage( new clExternalMemoryImage(
*vkNonDedicatedImage2DListDeviceMemory1 *vkImage2DListDeviceMemory1[bIdx],
[bIdx],
vkExternalMemoryHandleType, context, vkExternalMemoryHandleType, context,
totalImageMemSize, width, height, 0, totalImageMemSize, width, height, 0,
vkNonDedicatedImage2DList[bIdx], vkImage2DList[bIdx], deviceId));
deviceId));
} }
VulkanImageViewList vkNonDedicatedImage2DViewList( VulkanImageViewList vkImage2DViewList(
vkDevice, vkNonDedicatedImage2DList); vkDevice, vkImage2DList);
VulkanImage2DList vkNonDedicatedImage2DList2( VulkanImage2DList vkImage2DList2(
num2DImages, vkDevice, vkFormat, width, height, num2DImages, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType); vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
for (size_t bIdx = 0; bIdx < num2DImages; bIdx++) for (size_t bIdx = 0; bIdx < num2DImages; bIdx++)
{ {
if (non_dedicated) vkImage2DListDeviceMemory2.push_back(
{ new VulkanDeviceMemory(
vkNonDedicatedImage2DListDeviceMemory2 vkDevice, vkImage2DList2[bIdx],
.push_back(new VulkanDeviceMemory( memoryType,
vkDevice, totalImageMemSize, vkExternalMemoryHandleType));
memoryType, vkImage2DListDeviceMemory2[bIdx]->bindImage(
vkExternalMemoryHandleType)); vkImage2DList2[bIdx], 0);
} externalMemory2.push_back(
else
{
vkNonDedicatedImage2DListDeviceMemory2
.push_back(new VulkanDeviceMemory(
vkDevice,
vkNonDedicatedImage2DList2[bIdx],
memoryType,
vkExternalMemoryHandleType));
}
vkNonDedicatedImage2DListDeviceMemory2[bIdx]
->bindImage(
vkNonDedicatedImage2DList2[bIdx], 0);
nonDedicatedExternalMemory2.push_back(
new clExternalMemoryImage( new clExternalMemoryImage(
*vkNonDedicatedImage2DListDeviceMemory2 *vkImage2DListDeviceMemory2[bIdx],
[bIdx],
vkExternalMemoryHandleType, context, vkExternalMemoryHandleType, context,
totalImageMemSize, width, height, 0, totalImageMemSize, width, height, 0,
vkNonDedicatedImage2DList2[bIdx], vkImage2DList2[bIdx], deviceId));
deviceId));
} }
VulkanImageViewList vkDedicatedImage2DViewList(
vkDevice, vkNonDedicatedImage2DList2);
cl_mem external_mem_image1[5]; cl_mem external_mem_image1[5];
cl_mem external_mem_image2[5]; cl_mem external_mem_image2[5];
for (int i = 0; i < num2DImages; i++) for (int i = 0; i < num2DImages; i++)
{ {
external_mem_image1[i] = external_mem_image1[i] =
nonDedicatedExternalMemory1[i] externalMemory1[i]
->getExternalMemoryImage(); ->getExternalMemoryImage();
external_mem_image2[i] = external_mem_image2[i] =
nonDedicatedExternalMemory2[i] externalMemory2[i]
->getExternalMemoryImage(); ->getExternalMemoryImage();
} }
VulkanImage2DList &vkImage2DList =
vkNonDedicatedImage2DList;
VulkanImageViewList &vkImage2DViewList =
vkNonDedicatedImage2DViewList;
clCl2VkExternalSemaphore->signal(cmd_queue1); clCl2VkExternalSemaphore->signal(cmd_queue1);
if (!useSingleImageKernel) if (!useSingleImageKernel)
{ {
for (size_t i2DIdx = 0; vkDescriptorSet.updateArray(1,
i2DIdx < vkImage2DList.size(); i2DIdx++) vkImage2DViewList);
{
for (uint32_t mipLevel = 0;
mipLevel < numMipLevels; mipLevel++)
{
uint32_t i2DvIdx =
(uint32_t)(i2DIdx * numMipLevels)
+ mipLevel;
vkDescriptorSet.update(
1 + i2DvIdx,
vkImage2DViewList[i2DvIdx]);
}
}
vkCopyCommandBuffer.begin(); vkCopyCommandBuffer.begin();
vkCopyCommandBuffer.pipelineBarrier( vkCopyCommandBuffer.pipelineBarrier(
vkImage2DList, 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++) for (int i = 0; i < num2DImages; i++)
{ {
delete vkNonDedicatedImage2DListDeviceMemory1 delete vkImage2DListDeviceMemory1[i];
[i]; delete vkImage2DListDeviceMemory2[i];
delete vkNonDedicatedImage2DListDeviceMemory2 delete externalMemory1[i];
[i]; delete externalMemory2[i];
delete nonDedicatedExternalMemory1[i];
delete nonDedicatedExternalMemory2[i];
} }
vkNonDedicatedImage2DListDeviceMemory1.erase( vkImage2DListDeviceMemory1.erase(
vkNonDedicatedImage2DListDeviceMemory1.begin(), vkImage2DListDeviceMemory1.begin(),
vkNonDedicatedImage2DListDeviceMemory1.begin() vkImage2DListDeviceMemory1.begin()
+ num2DImages); + num2DImages);
vkNonDedicatedImage2DListDeviceMemory2.erase( vkImage2DListDeviceMemory2.erase(
vkNonDedicatedImage2DListDeviceMemory2.begin(), vkImage2DListDeviceMemory2.begin(),
vkNonDedicatedImage2DListDeviceMemory2.begin() vkImage2DListDeviceMemory2.begin()
+ num2DImages);
nonDedicatedExternalMemory1.erase(
nonDedicatedExternalMemory1.begin(),
nonDedicatedExternalMemory1.begin()
+ num2DImages);
nonDedicatedExternalMemory2.erase(
nonDedicatedExternalMemory2.begin(),
nonDedicatedExternalMemory2.begin()
+ num2DImages); + num2DImages);
externalMemory1.erase(externalMemory1.begin(),
externalMemory1.begin()
+ num2DImages);
externalMemory2.erase(externalMemory2.begin(),
externalMemory2.begin()
+ num2DImages);
if (CL_SUCCESS != err) if (CL_SUCCESS != err)
{ {
goto CLEANUP; goto CLEANUP;
@@ -822,9 +783,11 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
srcBufferPtr = (char *)malloc(maxImage2DSize); srcBufferPtr = (char *)malloc(maxImage2DSize);
dstBufferPtr = (char *)malloc(maxImage2DSize); dstBufferPtr = (char *)malloc(maxImage2DSize);
VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList( VulkanDescriptorSetLayoutBindingList vkDescriptorSetLayoutBindingList;
VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, vkDescriptorSetLayoutBindingList.addBinding(
VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_2D_IMAGE_DESCRIPTORS); 0, VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
vkDescriptorSetLayoutBindingList.addBinding(
1, VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_2D_IMAGE_DESCRIPTORS);
VulkanDescriptorSetLayout vkDescriptorSetLayout( VulkanDescriptorSetLayout vkDescriptorSetLayout(
vkDevice, vkDescriptorSetLayoutBindingList); vkDevice, vkDescriptorSetLayoutBindingList);
VulkanPipelineLayout vkPipelineLayout(vkDevice, vkDescriptorSetLayout); 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( clCl2VkExternalSemaphore = new clExternalSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId); vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
std::vector<VulkanDeviceMemory *> vkNonDedicatedImage2DListDeviceMemory1; std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkNonDedicatedImage2DListDeviceMemory2; std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2;
std::vector<clExternalMemoryImage *> nonDedicatedExternalMemory1; std::vector<clExternalMemoryImage *> externalMemory1;
std::vector<clExternalMemoryImage *> nonDedicatedExternalMemory2; std::vector<clExternalMemoryImage *> externalMemory2;
std::vector<char> vkImage2DShader; std::vector<char> vkImage2DShader;
for (size_t fIdx = 0; fIdx < vkFormatList.size(); fIdx++) 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. // Skip running for WIN32 NT handle.
continue; continue;
} }
VulkanImageTiling vulkanImageTiling =
vkClExternalMemoryHandleTilingAssumption(
deviceId,
vkExternalMemoryHandleTypeList[emhtIdx], &err);
ASSERT_SUCCESS(err,
"Failed to query OpenCL tiling mode");
VulkanImage2D vkDummyImage2D( VulkanImage2D vkDummyImage2D(
vkDevice, vkFormatList[0], widthList[0], vkDevice, vkFormatList[0], widthList[0],
heightList[0], 1, vkExternalMemoryHandleType); heightList[0], vulkanImageTiling, 1,
vkExternalMemoryHandleType);
const VulkanMemoryTypeList &memoryTypeList = const VulkanMemoryTypeList &memoryTypeList =
vkDummyImage2D.getMemoryTypeList(); vkDummyImage2D.getMemoryTypeList();
@@ -985,98 +957,78 @@ int run_test_with_one_queue(cl_context &context, cl_command_queue &cmd_queue1,
{ {
VulkanImage2D vkImage2D( VulkanImage2D vkImage2D(
vkDevice, vkFormat, width, height, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType); vulkanImageTiling, numMipLevels,
vkExternalMemoryHandleType);
ASSERT_LEQ(vkImage2D.getSize(), maxImage2DSize); ASSERT_LEQ(vkImage2D.getSize(), maxImage2DSize);
totalImageMemSize = totalImageMemSize =
ROUND_UP(vkImage2D.getSize(), ROUND_UP(vkImage2D.getSize(),
vkImage2D.getAlignment()); vkImage2D.getAlignment());
} }
VulkanImage2DList vkNonDedicatedImage2DList( VulkanImage2DList vkImage2DList(
num2DImages, vkDevice, vkFormat, width, height, num2DImages, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType); vulkanImageTiling, numMipLevels,
for (size_t bIdx = 0; vkExternalMemoryHandleType);
bIdx < vkNonDedicatedImage2DList.size(); for (size_t bIdx = 0; bIdx < vkImage2DList.size();
bIdx++) bIdx++)
{ {
// Create list of Vulkan device memories and // Create list of Vulkan device memories and
// bind the list of Vulkan images. // bind the list of Vulkan images.
vkNonDedicatedImage2DListDeviceMemory1 vkImage2DListDeviceMemory1.push_back(
.push_back(new VulkanDeviceMemory( new VulkanDeviceMemory(
vkDevice, totalImageMemSize, memoryType, vkDevice, vkImage2DList[bIdx],
memoryType,
vkExternalMemoryHandleType)); vkExternalMemoryHandleType));
vkNonDedicatedImage2DListDeviceMemory1[bIdx] vkImage2DListDeviceMemory1[bIdx]->bindImage(
->bindImage(vkNonDedicatedImage2DList[bIdx], vkImage2DList[bIdx], 0);
0); externalMemory1.push_back(
nonDedicatedExternalMemory1.push_back(
new clExternalMemoryImage( new clExternalMemoryImage(
*vkNonDedicatedImage2DListDeviceMemory1 *vkImage2DListDeviceMemory1[bIdx],
[bIdx],
vkExternalMemoryHandleType, context, vkExternalMemoryHandleType, context,
totalImageMemSize, width, height, 0, totalImageMemSize, width, height, 0,
vkNonDedicatedImage2DList[bIdx], vkImage2DList[bIdx], deviceId));
deviceId));
} }
VulkanImageViewList vkNonDedicatedImage2DViewList( VulkanImageViewList vkImage2DViewList(
vkDevice, vkNonDedicatedImage2DList); vkDevice, vkImage2DList);
VulkanImage2DList vkNonDedicatedImage2DList2( VulkanImage2DList vkImage2DList2(
num2DImages, vkDevice, vkFormat, width, height, num2DImages, vkDevice, vkFormat, width, height,
numMipLevels, vkExternalMemoryHandleType); vulkanImageTiling, numMipLevels,
for (size_t bIdx = 0; vkExternalMemoryHandleType);
bIdx < vkNonDedicatedImage2DList2.size(); for (size_t bIdx = 0; bIdx < vkImage2DList2.size();
bIdx++) bIdx++)
{ {
vkNonDedicatedImage2DListDeviceMemory2 vkImage2DListDeviceMemory2.push_back(
.push_back(new VulkanDeviceMemory( new VulkanDeviceMemory(
vkDevice, totalImageMemSize, memoryType, vkDevice, vkImage2DList2[bIdx],
memoryType,
vkExternalMemoryHandleType)); vkExternalMemoryHandleType));
vkNonDedicatedImage2DListDeviceMemory2[bIdx] vkImage2DListDeviceMemory2[bIdx]->bindImage(
->bindImage( vkImage2DList2[bIdx], 0);
vkNonDedicatedImage2DList2[bIdx], 0); externalMemory2.push_back(
nonDedicatedExternalMemory2.push_back(
new clExternalMemoryImage( new clExternalMemoryImage(
*vkNonDedicatedImage2DListDeviceMemory2 *vkImage2DListDeviceMemory2[bIdx],
[bIdx],
vkExternalMemoryHandleType, context, vkExternalMemoryHandleType, context,
totalImageMemSize, width, height, 0, totalImageMemSize, width, height, 0,
vkNonDedicatedImage2DList2[bIdx], vkImage2DList2[bIdx], deviceId));
deviceId));
} }
VulkanImageViewList vkDedicatedImage2DViewList(
vkDevice, vkNonDedicatedImage2DList2);
cl_mem external_mem_image1[4]; cl_mem external_mem_image1[4];
cl_mem external_mem_image2[4]; cl_mem external_mem_image2[4];
for (int i = 0; i < num2DImages; i++) for (int i = 0; i < num2DImages; i++)
{ {
external_mem_image1[i] = external_mem_image1[i] =
nonDedicatedExternalMemory1[i] externalMemory1[i]
->getExternalMemoryImage(); ->getExternalMemoryImage();
external_mem_image2[i] = external_mem_image2[i] =
nonDedicatedExternalMemory2[i] externalMemory2[i]
->getExternalMemoryImage(); ->getExternalMemoryImage();
} }
VulkanImage2DList &vkImage2DList =
vkNonDedicatedImage2DList;
VulkanImageViewList &vkImage2DViewList =
vkNonDedicatedImage2DViewList;
clCl2VkExternalSemaphore->signal(cmd_queue1); clCl2VkExternalSemaphore->signal(cmd_queue1);
if (!useSingleImageKernel) if (!useSingleImageKernel)
{ {
for (size_t i2DIdx = 0; vkDescriptorSet.updateArray(1,
i2DIdx < vkImage2DList.size(); i2DIdx++) vkImage2DViewList);
{
for (uint32_t mipLevel = 0;
mipLevel < numMipLevels; mipLevel++)
{
uint32_t i2DvIdx =
(uint32_t)(i2DIdx * numMipLevels)
+ mipLevel;
vkDescriptorSet.update(
1 + i2DvIdx,
vkImage2DViewList[i2DvIdx]);
}
}
vkCopyCommandBuffer.begin(); vkCopyCommandBuffer.begin();
vkCopyCommandBuffer.pipelineBarrier( vkCopyCommandBuffer.pipelineBarrier(
vkImage2DList, 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++) for (int i = 0; i < num2DImages; i++)
{ {
delete vkNonDedicatedImage2DListDeviceMemory1 delete vkImage2DListDeviceMemory1[i];
[i]; delete vkImage2DListDeviceMemory2[i];
delete vkNonDedicatedImage2DListDeviceMemory2 delete externalMemory1[i];
[i]; delete externalMemory2[i];
delete nonDedicatedExternalMemory1[i];
delete nonDedicatedExternalMemory2[i];
} }
vkNonDedicatedImage2DListDeviceMemory1.erase( vkImage2DListDeviceMemory1.erase(
vkNonDedicatedImage2DListDeviceMemory1.begin(), vkImage2DListDeviceMemory1.begin(),
vkNonDedicatedImage2DListDeviceMemory1.begin() vkImage2DListDeviceMemory1.begin()
+ num2DImages); + num2DImages);
vkNonDedicatedImage2DListDeviceMemory2.erase( vkImage2DListDeviceMemory2.erase(
vkNonDedicatedImage2DListDeviceMemory2.begin(), vkImage2DListDeviceMemory2.begin(),
vkNonDedicatedImage2DListDeviceMemory2.begin() vkImage2DListDeviceMemory2.begin()
+ num2DImages);
nonDedicatedExternalMemory1.erase(
nonDedicatedExternalMemory1.begin(),
nonDedicatedExternalMemory1.begin()
+ num2DImages);
nonDedicatedExternalMemory2.erase(
nonDedicatedExternalMemory2.begin(),
nonDedicatedExternalMemory2.begin()
+ num2DImages); + num2DImages);
externalMemory1.erase(externalMemory1.begin(),
externalMemory1.begin()
+ num2DImages);
externalMemory2.erase(externalMemory2.begin(),
externalMemory2.begin()
+ num2DImages);
if (CL_SUCCESS != err) if (CL_SUCCESS != err)
{ {
goto CLEANUP; goto CLEANUP;

1
test_conformance/vulkan/vulkan_interop_common.hpp
View File

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