From: Alexander Galazin Date: Thu, 14 Dec 2017 10:52:40 +0000 (+0100) Subject: Merge vk-gl-cts/vulkan-cts-1.0.2 into vk-gl-cts/vulkan-cts-1.1.0 X-Git-Tag: upstream/1.3.5~2565^2~6^2~45 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=63f65b30eac833357b90fc789529426d83567c36;p=platform%2Fupstream%2FVK-GL-CTS.git Merge vk-gl-cts/vulkan-cts-1.0.2 into vk-gl-cts/vulkan-cts-1.1.0 Change-Id: I3b358114c4158d2130e68632d4e02d7246c6f9af --- 63f65b30eac833357b90fc789529426d83567c36 diff --cc external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp index bbf7d86,071ce13..7626dd8 --- a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp +++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp @@@ -71,6 -72,178 +71,178 @@@ struct TestConfi const bool dedicated; }; + // A helper class to test for extensions upfront and throw not supported to speed up test runtimes compared to failing only + // after creating unnecessary vkInstances. A common example of this is win32 platforms taking a long time to run _fd tests. + class NotSupportedChecker + { + public: + NotSupportedChecker (const Context& context, + TestConfig config, + const OperationSupport& writeOp, + const OperationSupport& readOp) + : m_context (context) + { + // Check instance support + requireInstanceExtension("VK_KHR_get_physical_device_properties2"); + + requireInstanceExtension("VK_KHR_external_semaphore_capabilities"); + requireInstanceExtension("VK_KHR_external_memory_capabilities"); + + // Check device support + if (config.dedicated) + requireDeviceExtension("VK_KHR_dedicated_allocation"); + + requireDeviceExtension("VK_KHR_external_semaphore"); + requireDeviceExtension("VK_KHR_external_memory"); + + if (config.memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR + || config.semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR + || config.semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR) + { + requireDeviceExtension("VK_KHR_external_semaphore_fd"); + requireDeviceExtension("VK_KHR_external_memory_fd"); + } + + if (config.memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR + || config.memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR + || config.semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR + || config.semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR) + { + requireDeviceExtension("VK_KHR_external_semaphore_win32"); + requireDeviceExtension("VK_KHR_external_memory_win32"); + } + + TestLog& log = context.getTestContext().getLog(); + const vk::InstanceInterface& vki = context.getInstanceInterface(); + const vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); + + // Check resource support + if (config.resource.type == RESOURCE_TYPE_IMAGE) + { - 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, + config.memoryHandleType + }; - const vk::VkPhysicalDeviceImageFormatInfo2KHR imageFormatInfo = ++ const vk::VkPhysicalDeviceImageFormatInfo2 imageFormatInfo = + { - vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, ++ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + &externalInfo, + config.resource.imageFormat, + config.resource.imageType, + vk::VK_IMAGE_TILING_OPTIMAL, + readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags(), + 0u + }; - vk::VkExternalImageFormatPropertiesKHR externalProperties = ++ vk::VkExternalImageFormatProperties externalProperties = + { + vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, + DE_NULL, + { 0u, 0u, 0u } + }; - vk::VkImageFormatProperties2KHR formatProperties = ++ vk::VkImageFormatProperties2 formatProperties = + { - vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, ++ vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + &externalProperties, + { + { 0u, 0u, 0u }, + 0u, + 0u, + 0u, + 0u, + } + }; + + { - const vk::VkResult res = vki.getPhysicalDeviceImageFormatProperties2KHR(physicalDevice, &imageFormatInfo, &formatProperties); ++ const vk::VkResult res = vki.getPhysicalDeviceImageFormatProperties2(physicalDevice, &imageFormatInfo, &formatProperties); + + if (res == vk::VK_ERROR_FORMAT_NOT_SUPPORTED) + TCU_THROW(NotSupportedError, "Image format not supported"); + + VK_CHECK(res); // Check other errors + } + + log << TestLog::Message << "External image format properties: " << imageFormatInfo << "\n"<< externalProperties << TestLog::EndMessage; + + if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0) + TCU_THROW(NotSupportedError, "Exporting image resource not supported"); + + if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0) + TCU_THROW(NotSupportedError, "Importing image resource not supported"); + + if (!config.dedicated && (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0) + { + TCU_THROW(NotSupportedError, "Handle requires dedicated allocation, but test uses suballocated memory"); + } + } + else + { - 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, + + 0u, + readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags(), + config.memoryHandleType + }; - 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(physicalDevice, &info, &properties); ++ vki.getPhysicalDeviceExternalBufferProperties(physicalDevice, &info, &properties); + + log << TestLog::Message << "External buffer properties: " << info << "\n" << properties << TestLog::EndMessage; + + if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0 + || (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0) + TCU_THROW(NotSupportedError, "Exporting and importing memory type not supported"); + + if (!config.dedicated && (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0) + { + TCU_THROW(NotSupportedError, "Handle requires dedicated allocation, but test uses suballocated memory"); + } + } + + // Check semaphore support + { - 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, + config.semaphoreHandleType + }; - vk::VkExternalSemaphorePropertiesKHR properties; ++ vk::VkExternalSemaphoreProperties properties; + - vki.getPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, &info, &properties); ++ vki.getPhysicalDeviceExternalSemaphoreProperties(physicalDevice, &info, &properties); + + log << TestLog::Message << info << "\n" << properties << TestLog::EndMessage; + + if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR) == 0 + || (properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR) == 0) + TCU_THROW(NotSupportedError, "Exporting and importing semaphore type not supported"); + } + } + + private: + void requireDeviceExtension(const char* name) const + { + if (!de::contains(m_context.getDeviceExtensions().begin(), m_context.getDeviceExtensions().end(), name)) + TCU_THROW(NotSupportedError, (std::string(name) + " is not supported").c_str()); + } + + void requireInstanceExtension(const char* name) const + { + if (!de::contains(m_context.getInstanceExtensions().begin(), m_context.getInstanceExtensions().end(), name)) + TCU_THROW(NotSupportedError, (std::string(name) + " is not supported").c_str()); + } + + const Context& m_context; + }; + bool checkQueueFlags (vk::VkQueueFlags availableFlags, const vk::VkQueueFlags neededFlags) { if ((availableFlags & (vk::VK_QUEUE_GRAPHICS_BIT | vk::VK_QUEUE_COMPUTE_BIT)) != 0) @@@ -855,10 -1023,11 +1028,11 @@@ SharingTestInstance::SharingTestInstanc , m_config (config) , m_supportWriteOp (makeOperationSupport(config.writeOp, config.resource)) , m_supportReadOp (makeOperationSupport(config.readOp, config.resource)) + , m_notSupportedChecker (context, m_config, *m_supportWriteOp, *m_supportReadOp) - , m_instanceA (createInstance(context.getPlatformInterface())) + , m_instanceA (createInstance(context.getPlatformInterface(), context.getUsedApiVersion())) - , m_vkiA (context.getPlatformInterface(), *m_instanceA) + , m_vkiA (context.getPlatformInterface(), *m_instanceA) // \todo [2017-06-13 pyry] Provide correct extension list , m_physicalDeviceA (getPhysicalDevice(m_vkiA, *m_instanceA, context.getTestContext().getCommandLine())) , m_queueFamiliesA (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiA, m_physicalDeviceA)) , m_queueFamilyIndicesA (getFamilyIndices(m_queueFamiliesA))