#include "vkQueryUtil.hpp"
#include "vkPlatform.hpp"
#include "vkMemUtil.hpp"
+#include "vkApiVersion.hpp"
#include "tcuTestLog.hpp"
namespace
{
-vk::VkMemoryDedicatedRequirementsKHR getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkBuffer buffer)
+vk::VkMemoryDedicatedRequirements getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkBuffer buffer)
{
- const vk::VkBufferMemoryRequirementsInfo2KHR requirementInfo =
+ const vk::VkBufferMemoryRequirementsInfo2 requirementInfo =
{
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
buffer
};
- vk::VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ vk::VkMemoryDedicatedRequirements dedicatedRequirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
DE_NULL,
VK_FALSE,
VK_FALSE
};
- vk::VkMemoryRequirements2KHR requirements =
+ vk::VkMemoryRequirements2 requirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
&dedicatedRequirements,
{ 0u, 0u, 0u }
};
- vkd.getBufferMemoryRequirements2KHR(device, &requirementInfo, &requirements);
+ vkd.getBufferMemoryRequirements2(device, &requirementInfo, &requirements);
return dedicatedRequirements;
}
-vk::VkMemoryDedicatedRequirementsKHR getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkImage image)
+vk::VkMemoryDedicatedRequirements getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkImage image)
{
- const vk::VkImageMemoryRequirementsInfo2KHR requirementInfo =
+ const vk::VkImageMemoryRequirementsInfo2 requirementInfo =
{
- vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
image
};
- vk::VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ vk::VkMemoryDedicatedRequirements dedicatedRequirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
DE_NULL,
VK_FALSE,
VK_FALSE
};
- vk::VkMemoryRequirements2KHR requirements =
+ vk::VkMemoryRequirements2 requirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
&dedicatedRequirements,
{ 0u, 0u, 0u }
};
- vkd.getImageMemoryRequirements2KHR(device, &requirementInfo, &requirements);
+ vkd.getImageMemoryRequirements2(device, &requirementInfo, &requirements);
return dedicatedRequirements;
}
TCU_THROW(NotSupportedError, "Queue type not supported");
}
-vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp,
- const vk::VkExternalSemaphoreHandleTypeFlagsKHR externalSemaphoreTypes,
- const vk::VkExternalMemoryHandleTypeFlagsKHR externalMemoryTypes,
- const vk::VkExternalFenceHandleTypeFlagsKHR externalFenceTypes)
+std::vector<std::string> getInstanceExtensions (const deUint32 instanceVersion,
+ const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+ const vk::VkExternalFenceHandleTypeFlags externalFenceTypes)
{
std::vector<std::string> instanceExtensions;
- instanceExtensions.push_back("VK_KHR_get_physical_device_properties2");
+ if (!vk::isCoreInstanceExtension(instanceVersion, "VK_KHR_get_physical_device_properties2"))
+ instanceExtensions.push_back("VK_KHR_get_physical_device_properties2");
if (externalSemaphoreTypes != 0)
- instanceExtensions.push_back("VK_KHR_external_semaphore_capabilities");
+ if (!vk::isCoreInstanceExtension(instanceVersion, "VK_KHR_external_semaphore_capabilities"))
+ instanceExtensions.push_back("VK_KHR_external_semaphore_capabilities");
if (externalMemoryTypes != 0)
- instanceExtensions.push_back("VK_KHR_external_memory_capabilities");
+ if (!vk::isCoreInstanceExtension(instanceVersion, "VK_KHR_external_memory_capabilities"))
+ instanceExtensions.push_back("VK_KHR_external_memory_capabilities");
if (externalFenceTypes != 0)
- instanceExtensions.push_back("VK_KHR_external_fence_capabilities");
+ if (!vk::isCoreInstanceExtension(instanceVersion, "VK_KHR_external_fence_capabilities"))
+ instanceExtensions.push_back("VK_KHR_external_fence_capabilities");
+ return instanceExtensions;
+}
+
+vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp,
+ const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+ const vk::VkExternalFenceHandleTypeFlags externalFenceTypes)
+{
try
{
- return vk::createDefaultInstance(vkp, std::vector<std::string>(), instanceExtensions);
+ deUint32 version = 0u;
+ vkp.enumerateInstanceVersion(&version);
+ return vk::createDefaultInstance(vkp, version, std::vector<std::string>(), getInstanceExtensions(version, externalSemaphoreTypes, externalMemoryTypes, externalFenceTypes));
}
catch (const vk::Error& error)
{
}
}
-vk::Move<vk::VkDevice> createDevice (const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice physicalDevice,
- const vk::VkExternalSemaphoreHandleTypeFlagsKHR externalSemaphoreTypes,
- const vk::VkExternalMemoryHandleTypeFlagsKHR externalMemoryTypes,
- const vk::VkExternalFenceHandleTypeFlagsKHR externalFenceTypes,
- deUint32 queueFamilyIndex,
- bool useDedicatedAllocs = false)
+vk::Move<vk::VkDevice> createDevice (const deUint32 apiVersion,
+ const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice physicalDevice,
+ const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+ const vk::VkExternalFenceHandleTypeFlags externalFenceTypes,
+ deUint32 queueFamilyIndex,
+ bool useDedicatedAllocs = false)
{
std::vector<const char*> deviceExtensions;
if ((externalSemaphoreTypes
- & (vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- | vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ | vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_semaphore_fd");
}
if ((externalFenceTypes
- & (vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- | vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+ | vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_fence_fd");
}
if (useDedicatedAllocs)
{
- deviceExtensions.push_back("VK_KHR_dedicated_allocation");
- deviceExtensions.push_back("VK_KHR_get_memory_requirements2");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_dedicated_allocation"))
+ deviceExtensions.push_back("VK_KHR_dedicated_allocation");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_get_memory_requirements2"))
+ deviceExtensions.push_back("VK_KHR_get_memory_requirements2");
}
if ((externalMemoryTypes
- & vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR) != 0)
+ & vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT) != 0)
{
deviceExtensions.push_back("VK_KHR_external_memory_fd");
}
if ((externalSemaphoreTypes
- & (vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- | vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ | vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_semaphore_win32");
}
if ((externalFenceTypes
- & (vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- | vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ | vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_fence_win32");
}
if ((externalMemoryTypes
- & (vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_memory_win32");
}
return queue;
}
-void checkSemaphoreSupport (const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice device,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType)
+void checkSemaphoreSupport (const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice device,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
- const vk::VkPhysicalDeviceExternalSemaphoreInfoKHR info =
+ const vk::VkPhysicalDeviceExternalSemaphoreInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalSemaphorePropertiesKHR properties =
+ vk::VkExternalSemaphoreProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
DE_NULL,
0u,
0u,
0u
};
- vki.getPhysicalDeviceExternalSemaphorePropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalSemaphoreProperties(device, &info, &properties);
- if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Semaphore doesn't support exporting in external type");
- if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Semaphore doesn't support importing in external type");
}
-void checkFenceSupport (const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice device,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType)
+void checkFenceSupport (const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice device,
+ vk::VkExternalFenceHandleTypeFlagBits externalType)
{
- const vk::VkPhysicalDeviceExternalFenceInfoKHR info =
+ const vk::VkPhysicalDeviceExternalFenceInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalFencePropertiesKHR properties =
+ vk::VkExternalFenceProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
DE_NULL,
0u,
0u,
0u
};
- vki.getPhysicalDeviceExternalFencePropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalFenceProperties(device, &info, &properties);
- if ((properties.externalFenceFeatures & vk::VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalFenceFeatures & vk::VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Fence doesn't support exporting in external type");
- if ((properties.externalFenceFeatures & vk::VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalFenceFeatures & vk::VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Fence doesn't support importing in external type");
}
void checkBufferSupport (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice device,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkBufferViewCreateFlags createFlag,
vk::VkBufferUsageFlags usageFlag,
bool dedicated)
{
- const vk::VkPhysicalDeviceExternalBufferInfoKHR info =
+ const vk::VkPhysicalDeviceExternalBufferInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
DE_NULL,
createFlag,
usageFlag,
externalType
};
- vk::VkExternalBufferPropertiesKHR properties =
+ vk::VkExternalBufferProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
- vki.getPhysicalDeviceExternalBufferPropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalBufferProperties(device, &info, &properties);
- if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support exporting buffer");
- if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support importing buffer");
- if (!dedicated && (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0)
+ if (!dedicated && (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0)
TCU_THROW(NotSupportedError, "External handle type requires dedicated allocation");
}
-void checkImageSupport (const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice device,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
- vk::VkImageViewCreateFlags createFlag,
- vk::VkImageUsageFlags usageFlag,
- vk::VkFormat format,
- vk::VkImageTiling tiling,
- bool dedicated)
+void checkImageSupport (const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice device,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkImageViewCreateFlags createFlag,
+ vk::VkImageUsageFlags usageFlag,
+ vk::VkFormat format,
+ vk::VkImageTiling tiling,
+ bool dedicated)
{
- const vk::VkPhysicalDeviceExternalImageFormatInfoKHR externalInfo =
+ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
externalType
};
- const vk::VkPhysicalDeviceImageFormatInfo2KHR info =
+ const vk::VkPhysicalDeviceImageFormatInfo2 info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
&externalInfo,
format,
usageFlag,
createFlag,
};
- vk::VkExternalImageFormatPropertiesKHR externalProperties =
+ vk::VkExternalImageFormatProperties externalProperties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
- vk::VkImageFormatProperties2KHR properties =
+ vk::VkImageFormatProperties2 properties =
{
- vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+ vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
&externalProperties,
{
{ 0u, 0u, 0u },
}
};
- vki.getPhysicalDeviceImageFormatProperties2KHR(device, &info, &properties);
+ vki.getPhysicalDeviceImageFormatProperties2(device, &info, &properties);
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support exporting image");
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support importing image");
- if (!dedicated && (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0)
+ if (!dedicated && (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0)
TCU_THROW(NotSupportedError, "External handle type requires dedicated allocation");
}
vk::VkQueue queue,
deUint32 queueFamilyIndex,
vk::VkSemaphore semaphore,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
NativeHandle& nativeHandle)
{
const vk::Unique<vk::VkCommandPool> cmdPool(createCommandPool(vk, device, vk::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex, DE_NULL));
vk::VkQueue queue,
deUint32 queueFamilyIndex,
vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
NativeHandle& nativeHandle)
{
const vk::Unique<vk::VkCommandPool> cmdPool(createCommandPool(vk, device, vk::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex, DE_NULL));
VK_CHECK(vk.queueWaitIdle(queue));
}
-tcu::TestStatus testSemaphoreQueries (Context& context, vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType)
+tcu::TestStatus testSemaphoreQueries (Context& context, vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
const vk::Unique<vk::VkInstance> instance (createInstance(vkp, externalType, 0u, 0u));
TestLog& log = context.getTestContext().getLog();
- const vk::VkPhysicalDeviceExternalSemaphoreInfoKHR info =
+ const vk::VkPhysicalDeviceExternalSemaphoreInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalSemaphorePropertiesKHR properties =
+ vk::VkExternalSemaphoreProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
DE_NULL,
0u,
0u,
0u
};
- vki.getPhysicalDeviceExternalSemaphorePropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalSemaphoreProperties(device, &info, &properties);
log << TestLog::Message << properties << TestLog::EndMessage;
TCU_CHECK(properties.pNext == DE_NULL);
- TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR);
+ TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
return tcu::TestStatus::pass("Pass");
}
struct SemaphoreTestConfig
{
- SemaphoreTestConfig (vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType_,
+ SemaphoreTestConfig (vk::VkExternalSemaphoreHandleTypeFlagBits externalType_,
Permanence permanence_)
: externalType (externalType_)
, permanence (permanence_)
{
}
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType;
- Permanence permanence;
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType;
+ Permanence permanence;
};
tcu::TestStatus testSemaphoreWin32Create (Context& context,
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::VkExportSemaphoreWin32HandleInfoKHR win32ExportInfo =
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
DE_NULL
};
- const vk::VkExportSemaphoreCreateInfoKHR exportCreateInfo=
+ const vk::VkExportSemaphoreCreateInfo exportCreateInfo=
{
- vk::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
&win32ExportInfo,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)config.externalType
+ (vk::VkExternalMemoryHandleTypeFlags)config.externalType
};
const vk::VkSemaphoreCreateInfo createInfo =
{
if (transference == TRANSFERENCE_COPY)
submitDummySignal(vkd, queue, *semaphore);
- NativeHandle handleA;
+ NativeHandle handleA;
getSemaphoreNative(vkd, *device, *semaphore, config.externalType, handleA);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkSemaphore> semaphoreA (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkSemaphore> semaphoreA (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
if (transference == TRANSFERENCE_COPY)
submitDummyWait(vkd, queue, *semaphoreA);
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphore (createExportableSemaphore(vkd, *device, config.externalType));
{
NativeHandle handleB (handleA);
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkSemaphore> semaphoreA (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
const vk::Unique<vk::VkSemaphore> semaphoreB (createAndImportSemaphore(vkd, *device, config.externalType, handleB, flags));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
getSemaphoreNative(vkd, *device, *semaphoreA, config.externalType, handleA);
NativeHandle handleB (handleA);
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkSemaphore> semaphoreB (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
importSemaphore(vkd, *device, *semaphoreB, config.externalType, handleB, flags);
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
submitDummySignalAndGetSemaphoreNative(vkd, *device, queue, queueFamilyIndex, *semaphoreA, config.externalType, handle);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkSemaphore> semaphoreB (createAndImportSemaphore(vkd, *device, config.externalType, handle, flags));
submitDummyWait(vkd, queue, *semaphoreB);
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
DE_ASSERT(getHandelTypeTransferences(config.externalType) == TRANSFERENCE_REFERENCE);
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphore (createExportableSemaphore(vkd, *device, config.externalType));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
getSemaphoreNative(vkd, *device, *semaphoreB, config.externalType, secondFd);
}
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const int newFd (dup3(fd.getFd(), secondFd.getFd(), 0));
if (newFd < 0)
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
}
else
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const cmsghdr* const cmsg = CMSG_FIRSTHDR(&msg);
int newFd_;
deMemcpy(&newFd_, CMSG_DATA(cmsg), sizeof(int));
#endif
}
-tcu::TestStatus testFenceQueries (Context& context, vk::VkExternalFenceHandleTypeFlagBitsKHR externalType)
+tcu::TestStatus testFenceQueries (Context& context, vk::VkExternalFenceHandleTypeFlagBits externalType)
{
- const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, 0u, 0u, externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice device (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const vk::PlatformInterface& vkp (context.getPlatformInterface());
+ const vk::Unique<vk::VkInstance> instance (createInstance(vkp, 0u, 0u, externalType));
+ const vk::InstanceDriver vki (vkp, *instance);
+ const vk::VkPhysicalDevice device (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
- TestLog& log = context.getTestContext().getLog();
+ TestLog& log = context.getTestContext().getLog();
- const vk::VkPhysicalDeviceExternalFenceInfoKHR info =
+ const vk::VkPhysicalDeviceExternalFenceInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalFencePropertiesKHR properties =
+ vk::VkExternalFenceProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
DE_NULL,
0u,
0u,
0u
};
- vki.getPhysicalDeviceExternalFencePropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalFenceProperties(device, &info, &properties);
log << TestLog::Message << properties << TestLog::EndMessage;
TCU_CHECK(properties.pNext == DE_NULL);
- TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR);
+ TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
return tcu::TestStatus::pass("Pass");
}
struct FenceTestConfig
{
- FenceTestConfig (vk::VkExternalFenceHandleTypeFlagBitsKHR externalType_,
+ FenceTestConfig (vk::VkExternalFenceHandleTypeFlagBits externalType_,
Permanence permanence_)
: externalType (externalType_)
, permanence (permanence_)
{
}
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType;
- Permanence permanence;
+ vk::VkExternalFenceHandleTypeFlagBits externalType;
+ Permanence permanence;
};
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::VkExportFenceWin32HandleInfoKHR win32ExportInfo =
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
DE_NULL
};
- const vk::VkExportFenceCreateInfoKHR exportCreateInfo=
+ const vk::VkExportFenceCreateInfo exportCreateInfo=
{
- vk::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
&win32ExportInfo,
- (vk::VkExternalFenceHandleTypeFlagsKHR)config.externalType
+ (vk::VkExternalFenceHandleTypeFlags)config.externalType
};
const vk::VkFenceCreateInfo createInfo =
{
&exportCreateInfo,
0u
};
- const vk::Unique<vk::VkFence> fence (vk::createFence(vkd, *device, &createInfo));
+ const vk::Unique<vk::VkFence> fence (vk::createFence(vkd, *device, &createInfo));
if (transference == TRANSFERENCE_COPY)
submitDummySignal(vkd, queue, *fence);
- NativeHandle handleA;
+ NativeHandle handleA;
getFenceNative(vkd, *device, *fence, config.externalType, handleA);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkFence> fenceA (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkFence> fenceA (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
if (transference == TRANSFERENCE_COPY)
VK_CHECK(vkd.waitForFences(*device, 1u, &*fenceA, VK_TRUE, ~0ull));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fence (createExportableFence(vkd, *device, config.externalType));
{
NativeHandle handleB (handleA);
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkFence> fenceA (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
const vk::Unique<vk::VkFence> fenceB (createAndImportFence(vkd, *device, config.externalType, handleB, flags));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
getFenceNative(vkd, *device, *fenceA, config.externalType, handleA);
NativeHandle handleB (handleA);
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkFence> fenceB (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
importFence(vkd, *device, *fenceB, config.externalType, handleB, flags);
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
submitDummySignalAndGetFenceNative(vkd, *device, queue, queueFamilyIndex, *fenceA, config.externalType, handle);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkFence> fenceB (createAndImportFence(vkd, *device, config.externalType, handle, flags));
VK_CHECK(vkd.waitForFences(*device, 1u, &*fenceB, VK_TRUE, ~0ull));
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
DE_ASSERT(getHandelTypeTransferences(config.externalType) == TRANSFERENCE_REFERENCE);
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fence (createExportableFence(vkd, *device, config.externalType));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
getFenceNative(vkd, *device, *fenceB, config.externalType, secondFd);
}
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const int newFd (dup3(fd.getFd(), secondFd.getFd(), 0));
if (newFd < 0)
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
}
else
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const cmsghdr* const cmsg = CMSG_FIRSTHDR(&msg);
int newFd_;
deMemcpy(&newFd_, CMSG_DATA(cmsg), sizeof(int));
#endif
}
-tcu::TestStatus testBufferQueries (Context& context, vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+tcu::TestStatus testBufferQueries (Context& context, vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
const vk::VkBufferCreateFlags createFlags[] =
{
{
const vk::VkBufferViewCreateFlags createFlag = createFlags[createFlagNdx];
const vk::VkBufferUsageFlags usageFlag = usageFlags[usageFlagNdx];
- const vk::VkPhysicalDeviceExternalBufferInfoKHR info =
+ const vk::VkPhysicalDeviceExternalBufferInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
DE_NULL,
createFlag,
usageFlag,
externalType
};
- vk::VkExternalBufferPropertiesKHR properties =
+ vk::VkExternalBufferProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
(deviceFeatures.sparseResidencyBuffer == VK_FALSE))
continue;
- vki.getPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, &info, &properties);
+ vki.getPhysicalDeviceExternalBufferProperties(physicalDevice, &info, &properties);
log << TestLog::Message << properties << TestLog::EndMessage;
- TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR);
+ TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
TCU_CHECK(properties.pNext == DE_NULL);
// \todo [2017-06-06 pyry] Can we validate anything else? Compatible types?
- if ((properties.externalMemoryProperties.externalMemoryFeatures & (vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR)) != 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & (vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT)) != 0)
{
- const bool requiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0;
+ const bool requiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
if (!device || (requiresDedicated && !deviceHasDedicated))
{
// \note We need to re-create with dedicated mem extensions if previous device instance didn't have them
try
{
- device = createDevice(vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
+ device = createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
vkd = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(vki, *device));
deviceHasDedicated = requiresDedicated;
}
}
}
- if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) != 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) != 0)
{
DE_ASSERT(!!device);
DE_ASSERT(vkd);
if (deviceHasDedicated)
{
const vk::Unique<vk::VkBuffer> buffer (createExternalBuffer(*vkd, *device, queueFamilyIndex, externalType, 1024u, createFlag, usageFlag));
- const vk::VkMemoryDedicatedRequirementsKHR reqs (getMemoryDedicatedRequirements(*vkd, *device, *buffer));
- const bool propertiesRequiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0;
+ const vk::VkMemoryDedicatedRequirements reqs (getMemoryDedicatedRequirements(*vkd, *device, *buffer));
+ const bool propertiesRequiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
const bool objectRequiresDedicated = (reqs.requiresDedicatedAllocation != VK_FALSE);
if (propertiesRequiresDedicated != objectRequiresDedicated)
// This check should be redundant as the code above tries to create device with
// VK_KHR_dedicated_allocation & VK_KHR_get_memory_requirements2 if dedicated memory
// is required. However, checking again doesn't hurt.
- TCU_CHECK((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) == 0);
+ TCU_CHECK((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) == 0);
}
}
}
struct MemoryTestConfig
{
- MemoryTestConfig (vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType_,
+ MemoryTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
bool hostVisible_,
bool dedicated_)
: externalType (externalType_)
{
}
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType;
- bool hostVisible;
- bool dedicated;
+ vk::VkExternalMemoryHandleTypeFlagBits externalType;
+ bool hostVisible;
+ bool dedicated;
};
#if (DE_OS == DE_OS_WIN32)
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const deUint32 seed = 1261033864u;
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
DE_NULL
};
- const vk::VkExportMemoryAllocateInfoKHR exportInfo =
+ const vk::VkExportMemoryAllocateInfo exportInfo =
{
- vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
&win32Info,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)config.externalType
+ (vk::VkExternalMemoryHandleTypeFlags)config.externalType
};
exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits & compatibleMemTypes);
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const deUint32 seed = 1261033864u;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
TestLog& log = context.getTestContext().getLog();
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
TestLog& log = context.getTestContext().getLog();
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
TestLog& log = context.getTestContext().getLog();
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
TestLog& log = context.getTestContext().getLog();
struct BufferTestConfig
{
- BufferTestConfig (vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType_,
- bool dedicated_)
+ BufferTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
+ bool dedicated_)
: externalType (externalType_)
, dedicated (dedicated_)
{
}
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType;
- bool dedicated;
+ vk::VkExternalMemoryHandleTypeFlagBits externalType;
+ bool dedicated;
};
tcu::TestStatus testBufferBindExportImportBind (Context& context,
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
return tcu::TestStatus::pass("Pass");
}
-tcu::TestStatus testImageQueries (Context& context, vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+tcu::TestStatus testImageQueries (Context& context, vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
const vk::VkImageCreateFlags createFlags[] =
{
vk::VK_IMAGE_CREATE_SPARSE_BINDING_BIT|vk::VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
vk::VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
vk::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
- vk::VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR
+ vk::VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT
};
const vk::VkImageUsageFlags usageFlags[] =
{
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
const vk::VkImageType type = vk::VK_IMAGE_TYPE_2D;
const vk::VkImageTiling tiling = vk::VK_IMAGE_TILING_OPTIMAL;
- const vk::VkPhysicalDeviceExternalImageFormatInfoKHR externalInfo =
+ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
externalType
};
- const vk::VkPhysicalDeviceImageFormatInfo2KHR info =
+ const vk::VkPhysicalDeviceImageFormatInfo2 info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
&externalInfo,
format,
usageFlag,
createFlag,
};
- vk::VkExternalImageFormatPropertiesKHR externalProperties =
+ vk::VkExternalImageFormatProperties externalProperties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
- vk::VkImageFormatProperties2KHR properties =
+ vk::VkImageFormatProperties2 properties =
{
- vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+ vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
&externalProperties,
{
{ 0u, 0u, 0u },
(deviceFeatures.sparseResidencyAliased == VK_FALSE))
continue;
- vki.getPhysicalDeviceImageFormatProperties2KHR(physicalDevice, &info, &properties);
+ vki.getPhysicalDeviceImageFormatProperties2(physicalDevice, &info, &properties);
log << TestLog::Message << externalProperties << TestLog::EndMessage;
- TCU_CHECK(externalProperties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR);
+ TCU_CHECK(externalProperties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
TCU_CHECK(externalProperties.pNext == DE_NULL);
// \todo [2017-06-06 pyry] Can we validate anything else? Compatible types?
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & (vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR)) != 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & (vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT)) != 0)
{
- const bool requiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0;
+ const bool requiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
if (!device || (requiresDedicated && !deviceHasDedicated))
{
// \note We need to re-create with dedicated mem extensions if previous device instance didn't have them
try
{
- device = createDevice(vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
+ device = createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
vkd = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(vki, *device));
deviceHasDedicated = requiresDedicated;
}
}
}
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) != 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) != 0)
{
DE_ASSERT(!!device);
DE_ASSERT(vkd);
if (deviceHasDedicated)
{
const vk::Unique<vk::VkImage> image (createExternalImage(*vkd, *device, queueFamilyIndex, externalType, format, 16u, 16u, tiling, createFlag, usageFlag));
- const vk::VkMemoryDedicatedRequirementsKHR reqs (getMemoryDedicatedRequirements(*vkd, *device, *image));
- const bool propertiesRequiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0;
+ const vk::VkMemoryDedicatedRequirements reqs (getMemoryDedicatedRequirements(*vkd, *device, *image));
+ const bool propertiesRequiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
const bool objectRequiresDedicated = (reqs.requiresDedicatedAllocation != VK_FALSE);
if (propertiesRequiresDedicated != objectRequiresDedicated)
// This check should be redundant as the code above tries to create device with
// VK_KHR_dedicated_allocation & VK_KHR_get_memory_requirements2 if dedicated memory
// is required. However, checking again doesn't hurt.
- TCU_CHECK((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) == 0);
+ TCU_CHECK((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) == 0);
}
}
}
struct ImageTestConfig
{
- ImageTestConfig (vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType_,
- bool dedicated_)
+ ImageTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
+ bool dedicated_)
: externalType (externalType_)
, dedicated (dedicated_)
{
}
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType;
- bool dedicated;
+ vk::VkExternalMemoryHandleTypeFlagBits externalType;
+ bool dedicated;
};
tcu::TestStatus testImageBindExportImportBind (Context& context,
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkImageUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
{
- const vk::Unique<vk::VkDeviceMemory> memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
const vk::Unique<vk::VkImage> imageB (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+ const vk::Unique<vk::VkDeviceMemory> memoryB (config.dedicated
+ ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, exportedMemoryTypeIndex, handle)
+ : importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
VK_CHECK(vkd.bindImageMemory(*device, *imageB, *memoryB, 0u));
}
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkImageUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));
{
- const vk::Unique<vk::VkDeviceMemory> memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
const vk::Unique<vk::VkImage> imageB (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+ const vk::Unique<vk::VkDeviceMemory> memoryB (config.dedicated
+ ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, exportedMemoryTypeIndex, handle)
+ : importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
VK_CHECK(vkd.bindImageMemory(*device, *imageB, *memoryB, 0u));
}
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkImageUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
{
- const vk::Unique<vk::VkDeviceMemory> memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
const vk::Unique<vk::VkImage> imageB (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+ const vk::Unique<vk::VkDeviceMemory> memoryB (config.dedicated
+ ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, exportedMemoryTypeIndex, handle)
+ : importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));
VK_CHECK(vkd.bindImageMemory(*device, *imageB, *memoryB, 0u));
return tcu::TestStatus::pass("Pass");
}
-de::MovePtr<tcu::TestCaseGroup> createFenceTests (tcu::TestContext& testCtx, vk::VkExternalFenceHandleTypeFlagBitsKHR externalType)
+de::MovePtr<tcu::TestCaseGroup> createFenceTests (tcu::TestContext& testCtx, vk::VkExternalFenceHandleTypeFlagBits externalType)
{
const struct
{
if (!isSupportedPermanence(externalType, permanence))
continue;
- if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
addFunctionCase(fenceGroup.get(), std::string("create_win32_") + permanenceName, "Test creating fence with win32 properties.", testFenceWin32Create, config);
}
addFunctionCase(fenceGroup.get(), std::string("reset_") + permanenceName, "Test resetting the fence.", testFenceReset, config);
addFunctionCase(fenceGroup.get(), std::string("transference_") + permanenceName, "Test fences transference.", testFenceTransference, config);
- if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+ || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
// \note Not supported on WIN32 handles
addFunctionCase(fenceGroup.get(), std::string("export_multiple_times_") + permanenceName, "Test exporting fence multiple times.", testFenceMultipleExports, config);
{
de::MovePtr<tcu::TestCaseGroup> fenceGroup (new tcu::TestCaseGroup(testCtx, "fence", "Tests for external fences."));
- fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR).release());
- fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR).release());
- fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR).release());
- fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR).release());
+ fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT).release());
+ fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT).release());
+ fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT).release());
+ fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT).release());
return fenceGroup;
}
-de::MovePtr<tcu::TestCaseGroup> createSemaphoreTests (tcu::TestContext& testCtx, vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType)
+de::MovePtr<tcu::TestCaseGroup> createSemaphoreTests (tcu::TestContext& testCtx, vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
const struct
{
if (!isSupportedPermanence(externalType, permanence))
continue;
- if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
addFunctionCase(semaphoreGroup.get(), std::string("create_win32_") + permanenceName, "Test creating semaphore with win32 properties.", testSemaphoreWin32Create, config);
}
addFunctionCase(semaphoreGroup.get(), std::string("signal_import_") + permanenceName, "Test signaling and importing the semaphore.", testSemaphoreSignalImport, config);
addFunctionCase(semaphoreGroup.get(), std::string("transference_") + permanenceName, "Test semaphores transference.", testSemaphoreTransference, config);
- if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
// \note Not supported on WIN32 handles
addFunctionCase(semaphoreGroup.get(), std::string("export_multiple_times_") + permanenceName, "Test exporting semaphore multiple times.", testSemaphoreMultipleExports, config);
{
de::MovePtr<tcu::TestCaseGroup> semaphoreGroup (new tcu::TestCaseGroup(testCtx, "semaphore", "Tests for external semaphores."));
- semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR).release());
- semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR).release());
- semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR).release());
- semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR).release());
+ semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT).release());
+ semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT).release());
+ semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT).release());
+ semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT).release());
return semaphoreGroup;
}
-de::MovePtr<tcu::TestCaseGroup> createMemoryTests (tcu::TestContext& testCtx, vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+de::MovePtr<tcu::TestCaseGroup> createMemoryTests (tcu::TestContext& testCtx, vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, externalMemoryTypeToName(externalType), "Tests for external memory"));
de::MovePtr<tcu::TestCaseGroup> hostVisibleGroup (new tcu::TestCaseGroup(testCtx, hostVisible ? "host_visible" : "device_only", ""));
const MemoryTestConfig memoryConfig (externalType, hostVisible, dedicated);
- if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
addFunctionCase(hostVisibleGroup.get(), "create_win32", "Test creating memory with win32 properties .", testMemoryWin32Create, memoryConfig);
}
addFunctionCase(hostVisibleGroup.get(), "import_twice", "Test importing memory object twice.", testMemoryImportTwice, memoryConfig);
addFunctionCase(hostVisibleGroup.get(), "import_multiple_times", "Test importing memory object multiple times.", testMemoryMultimpleImports, memoryConfig);
- if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
{
addFunctionCase(hostVisibleGroup.get(), "dup", "Test calling dup() on exported memory.", testMemoryFdDup, memoryConfig);
addFunctionCase(hostVisibleGroup.get(), "dup2", "Test calling dup2() on exported memory.", testMemoryFdDup2, memoryConfig);
{
de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "memory", "Tests for external memory"));
- group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR).release());
- group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR).release());
- group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR).release());
+ group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT).release());
+ group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT).release());
+ group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT).release());
return group;
}
projects / platform / upstream / VK-GL-CTS.git / blobdiff