const bool dedicated;
};
- const vk::VkPhysicalDeviceExternalImageFormatInfoKHR externalInfo =
+ // 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)
+ {
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
++ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
+ {
- const vk::VkPhysicalDeviceImageFormatInfo2KHR imageFormatInfo =
++ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
+ DE_NULL,
+ config.memoryHandleType
+ };
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
++ const vk::VkPhysicalDeviceImageFormatInfo2 imageFormatInfo =
+ {
- vk::VkExternalImageFormatPropertiesKHR externalProperties =
++ 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::VkImageFormatProperties2KHR formatProperties =
++ vk::VkExternalImageFormatProperties externalProperties =
+ {
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+ DE_NULL,
+ { 0u, 0u, 0u }
+ };
- vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
++ vk::VkImageFormatProperties2 formatProperties =
+ {
- const vk::VkResult res = vki.getPhysicalDeviceImageFormatProperties2KHR(physicalDevice, &imageFormatInfo, &formatProperties);
++ vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
+ &externalProperties,
+ {
+ { 0u, 0u, 0u },
+ 0u,
+ 0u,
+ 0u,
+ 0u,
+ }
+ };
+
+ {
- const vk::VkPhysicalDeviceExternalBufferInfoKHR info =
++ 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
+ {
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
++ const vk::VkPhysicalDeviceExternalBufferInfo info =
+ {
- vk::VkExternalBufferPropertiesKHR properties =
++ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
+ DE_NULL,
+
+ 0u,
+ readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags(),
+ config.memoryHandleType
+ };
- vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
++ vk::VkExternalBufferProperties properties =
+ {
- vki.getPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, &info, &properties);
++ vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
+ DE_NULL,
+ { 0u, 0u, 0u}
+ };
- const vk::VkPhysicalDeviceExternalSemaphoreInfoKHR info =
++ 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
+ {
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
++ const vk::VkPhysicalDeviceExternalSemaphoreInfo info =
+ {
- vk::VkExternalSemaphorePropertiesKHR properties;
++ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
+ DE_NULL,
+ config.semaphoreHandleType
+ };
- vki.getPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, &info, &properties);
++ vk::VkExternalSemaphoreProperties 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)
, 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))
projects / platform / upstream / VK-GL-CTS.git / commitdiff