| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2021 The Khronos Group Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Vulkan SC API Tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktSafetyCriticalApiTests.hpp" |
| |
| #include <set> |
| #include <vector> |
| #include <string> |
| |
| #include "vkDefs.hpp" |
| #include "vktTestCaseUtil.hpp" |
| #include "vkQueryUtil.hpp" |
| |
| namespace vkt |
| { |
| namespace sc |
| { |
| namespace |
| { |
| |
| tcu::TestStatus forbiddenCoreCommands (Context& context) |
| { |
| std::vector<std::string> commands |
| { |
| "vkTrimCommandPool", |
| "vkTrimCommandPoolKHR", |
| "vkDestroyCommandPool", |
| "vkCreateShaderModule", |
| "vkDestroyShaderModule", |
| "vkMergePipelineCaches", |
| "vkGetPipelineCacheData", |
| "vkFreeMemory", |
| "vkDestroyDescriptorPool", |
| "vkCreateDescriptorUpdateTemplateKHR", |
| "vkDestroyDescriptorUpdateTemplateKHR", |
| "vkUpdateDescriptorSetWithTemplateKHR", |
| "vkCmdPushDescriptorSetWithTemplateKHR", |
| "vkDestroyQueryPool", |
| "vkGetPhysicalDeviceSparseImageFormatProperties", |
| "vkGetPhysicalDeviceSparseImageFormatProperties2", |
| "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", |
| "vkGetImageSparseMemoryRequirements", |
| "vkGetImageSparseMemoryRequirements2", |
| "vkGetImageSparseMemoryRequirements2KHR", |
| "vkQueueBindSparse", |
| "vkDestroySwapchainKHR" |
| }; |
| |
| vk::VkDevice device = context.getDevice(); |
| const vk::DeviceInterface& vkd = context.getDeviceInterface(); |
| |
| for (const auto& commandName : commands) |
| { |
| void* commandPointer = (void *)vkd.getDeviceProcAddr(device, commandName.c_str()); |
| if( commandPointer != DE_NULL ) |
| TCU_THROW(TestError, commandName + std::string(" should not be accessible")); |
| } |
| |
| return tcu::TestStatus::pass("All forbidden commands are not accessible"); |
| } |
| |
| tcu::TestStatus forbiddenCoreExtensions (Context& context) |
| { |
| // vector of Vulkan 1.1 and Vulkan 1.2 extensions that should not be advertised in Vulkan SC 1.0 |
| std::set<std::string> coreExtensions |
| { |
| "VK_KHR_16bit_storage", |
| "VK_KHR_bind_memory2", |
| "VK_KHR_dedicated_allocation", |
| "VK_KHR_descriptor_update_template", |
| "VK_KHR_device_group", |
| "VK_KHR_device_group_creation", |
| "VK_KHR_external_fence", |
| "VK_KHR_external_fence_capabilities", |
| "VK_KHR_external_memory", |
| "VK_KHR_external_memory_capabilities", |
| "VK_KHR_external_semaphore", |
| "VK_KHR_external_semaphore_capabilities", |
| "VK_KHR_get_memory_requirements2", |
| "VK_KHR_get_physical_device_properties2", |
| "VK_KHR_maintenance1", |
| "VK_KHR_maintenance2", |
| "VK_KHR_maintenance3", |
| "VK_KHR_multiview", |
| "VK_KHR_relaxed_block_layout", |
| "VK_KHR_sampler_ycbcr_conversion", |
| "VK_KHR_shader_draw_parameters", |
| "VK_KHR_storage_buffer_storage_class", |
| "VK_KHR_variable_pointers", |
| "VK_KHR_8bit_storage", |
| "VK_KHR_buffer_device_address", |
| "VK_KHR_create_renderpass2", |
| "VK_KHR_depth_stencil_resolve", |
| "VK_KHR_draw_indirect_count", |
| "VK_KHR_driver_properties", |
| "VK_KHR_image_format_list", |
| "VK_KHR_imageless_framebuffer", |
| "VK_KHR_sampler_mirror_clamp_to_edge", |
| "VK_KHR_separate_depth_stencil_layouts", |
| "VK_KHR_shader_atomic_int64", |
| "VK_KHR_shader_float16_int8", |
| "VK_KHR_shader_float_controls", |
| "VK_KHR_shader_subgroup_extended_types", |
| "VK_KHR_spirv_1_4", |
| "VK_KHR_timeline_semaphore", |
| "VK_KHR_uniform_buffer_standard_layout", |
| "VK_KHR_vulkan_memory_model", |
| "VK_EXT_descriptor_indexing", |
| "VK_EXT_host_query_reset", |
| "VK_EXT_sampler_filter_minmax", |
| "VK_EXT_scalar_block_layout", |
| "VK_EXT_separate_stencil_usage", |
| "VK_EXT_shader_viewport_index_layer", |
| }; |
| |
| vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); |
| const vk::InstanceInterface& vki = context.getInstanceInterface(); |
| const std::vector<vk::VkExtensionProperties> deviceExtensions = vk::enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); |
| |
| for (const auto& extension : deviceExtensions) |
| { |
| const std::string extensionName(extension.extensionName); |
| if(coreExtensions.find(extensionName)!= coreExtensions.end()) |
| TCU_THROW(TestError, extensionName + std::string(" extension is explicitly forbidden")); |
| } |
| |
| return tcu::TestStatus::pass("No extensions from forbidden set"); |
| } |
| |
| tcu::TestStatus forbiddenPromotedCommands (Context& context) |
| { |
| std::vector<std::string> commands |
| { |
| "vkBindBufferMemory2KHR", |
| "vkBindImageMemory2KHR", |
| "vkCreateDescriptorUpdateTemplateKHR", |
| "vkDestroyDescriptorUpdateTemplateKHR", |
| "vkUpdateDescriptorSetWithTemplateKHR", |
| "vkCmdPushDescriptorSetWithTemplateKHR", |
| "vkCmdDispatchBaseKHR", |
| "vkCmdSetDeviceMaskKHR", |
| "vkGetDeviceGroupPeerMemoryFeaturesKHR", |
| "vkEnumeratePhysicalDeviceGroupsKHR", |
| "vkGetPhysicalDeviceExternalFencePropertiesKHR", |
| "vkGetPhysicalDeviceExternalBufferPropertiesKHR", |
| "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", |
| "vkGetBufferMemoryRequirements2KHR", |
| "vkGetImageMemoryRequirements2KHR", |
| "vkGetImageSparseMemoryRequirements2KHR", |
| "vkGetPhysicalDeviceFeatures2KHR", |
| "vkGetPhysicalDeviceFormatProperties2KHR", |
| "vkGetPhysicalDeviceImageFormatProperties2KHR", |
| "vkGetPhysicalDeviceMemoryProperties2KHR", |
| "vkGetPhysicalDeviceProperties2KHR", |
| "vkGetPhysicalDeviceQueueFamilyProperties2KHR", |
| "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", |
| "vkTrimCommandPoolKHR", |
| "vkGetDescriptorSetLayoutSupportKHR", |
| "vkCreateSamplerYcbcrConversionKHR", |
| "vkDestroySamplerYcbcrConversionKHR", |
| "vkGetBufferDeviceAddressKHR", |
| "vkGetBufferOpaqueCaptureAddressKHR", |
| "vkGetDeviceMemoryOpaqueCaptureAddressKHR", |
| "vkCmdBeginRenderPass2KHR", |
| "vkCmdEndRenderPass2KHR", |
| "vkCmdNextSubpass2KHR", |
| "vkCreateRenderPass2KHR", |
| "vkCmdDrawIndexedIndirectCountKHR", |
| "vkCmdDrawIndirectCountKHR", |
| "vkGetSemaphoreCounterValueKHR", |
| "vkSignalSemaphoreKHR", |
| "vkWaitSemaphoresKHR", |
| "vkResetQueryPoolEXT", |
| }; |
| |
| vk::VkDevice device = context.getDevice(); |
| const vk::DeviceInterface& vkd = context.getDeviceInterface(); |
| |
| for (const auto& commandName : commands) |
| { |
| void* commandPointer = (void *)vkd.getDeviceProcAddr(device, commandName.c_str()); |
| if( commandPointer != DE_NULL ) |
| TCU_THROW(TestError, commandName + std::string(" should not be accessible")); |
| } |
| |
| return tcu::TestStatus::pass("All forbidden commands are not accessible"); |
| } |
| |
| tcu::TestStatus forbiddenDeviceFeatures (Context& context) |
| { |
| if (context.getDeviceFeatures().shaderResourceResidency != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::shaderResourceResidency must be VK_FALSE"); |
| if (context.getDeviceFeatures().sparseBinding != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseBinding must be VK_FALSE"); |
| |
| if (context.getDeviceFeatures().sparseResidencyBuffer != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseResidencyBuffer must be VK_FALSE"); |
| if (context.getDeviceFeatures().sparseResidencyImage2D != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseResidencyImage2D must be VK_FALSE"); |
| if (context.getDeviceFeatures().sparseResidencyImage3D != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseResidencyImage3D must be VK_FALSE"); |
| if (context.getDeviceFeatures().sparseResidency2Samples != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseResidency2Samples must be VK_FALSE"); |
| if (context.getDeviceFeatures().sparseResidency4Samples != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseResidency4Samples must be VK_FALSE"); |
| if (context.getDeviceFeatures().sparseResidency8Samples != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseResidency8Samples must be VK_FALSE"); |
| if (context.getDeviceFeatures().sparseResidency16Samples != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseResidency16Samples must be VK_FALSE"); |
| if (context.getDeviceFeatures().sparseResidencyAliased != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceFeatures::sparseResidencyAliased must be VK_FALSE"); |
| |
| return tcu::TestStatus::pass("Pass"); |
| } |
| |
| tcu::TestStatus forbiddenDeviceProperties (Context& context) |
| { |
| if (context.getDeviceProperties().sparseProperties.residencyStandard2DBlockShape != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceSparseProperties::residencyStandard2DBlockShape must be VK_FALSE"); |
| if (context.getDeviceProperties().sparseProperties.residencyStandard2DMultisampleBlockShape != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceSparseProperties::residencyStandard2DMultisampleBlockShape must be VK_FALSE"); |
| if (context.getDeviceProperties().sparseProperties.residencyStandard3DBlockShape != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceSparseProperties::residencyStandard3DBlockShape must be VK_FALSE"); |
| if (context.getDeviceProperties().sparseProperties.residencyAlignedMipSize != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceSparseProperties::residencyAlignedMipSize must be VK_FALSE"); |
| if (context.getDeviceProperties().sparseProperties.residencyNonResidentStrict != VK_FALSE) |
| TCU_THROW(TestError, "VkPhysicalDeviceSparseProperties::residencyNonResidentStrict must be VK_FALSE"); |
| |
| return tcu::TestStatus::pass("Pass"); |
| } |
| |
| tcu::TestStatus allowedExtensions (Context& context) |
| { |
| // vector of extensions that are explicitly allowed in Vulkan SC 1.0 |
| std::set<std::string> extensions |
| { |
| "VK_KHR_copy_commands2", |
| "VK_KHR_display", |
| "VK_KHR_display_swapchain", |
| "VK_KHR_external_fence_fd", |
| "VK_KHR_external_memory_fd", |
| "VK_KHR_external_semaphore_fd", |
| "VK_KHR_fragment_shading_rate", |
| "VK_KHR_get_display_properties2", |
| "VK_KHR_get_surface_capabilities2", |
| "VK_KHR_incremental_present", |
| "VK_KHR_object_refresh", |
| "VK_KHR_shader_clock", |
| "VK_KHR_shader_terminate_invocation", |
| "VK_KHR_shared_presentable_image", |
| "VK_KHR_surface", |
| "VK_KHR_swapchain", |
| "VK_KHR_swapchain_mutable_format", |
| "VK_KHR_synchronization2", |
| "VK_EXT_4444_formats", |
| "VK_EXT_astc_decode_mode", |
| "VK_EXT_blend_operation_advanced", |
| "VK_EXT_calibrated_timestamps", |
| "VK_EXT_color_write_enable", |
| "VK_EXT_conservative_rasterization", |
| "VK_EXT_custom_border_color", |
| "VK_EXT_debug_utils", |
| "VK_EXT_depth_clip_enable", |
| "VK_EXT_depth_range_unrestricted", |
| "VK_EXT_direct_mode_display", |
| "VK_EXT_discard_rectangles", |
| "VK_EXT_display_control", |
| "VK_EXT_display_surface_counter", |
| "VK_EXT_extended_dynamic_state", |
| "VK_EXT_extended_dynamic_state2", |
| "VK_EXT_external_memory_dma_buf", |
| "VK_EXT_external_memory_host", |
| "VK_EXT_filter_cubic", |
| "VK_EXT_fragment_shader_interlock", |
| "VK_EXT_global_priority", |
| "VK_EXT_hdr_metadata", |
| "VK_EXT_headless_surface", |
| "VK_EXT_image_drm_format_modifier", |
| "VK_EXT_image_robustness", |
| "VK_EXT_index_type_uint8", |
| "VK_EXT_line_rasterization", |
| "VK_EXT_memory_budget", |
| "VK_EXT_pci_bus_info", |
| "VK_EXT_post_depth_coverage", |
| "VK_EXT_queue_family_foreign", |
| "VK_EXT_robustness2", |
| "VK_EXT_sample_locations", |
| "VK_EXT_shader_atomic_float", |
| "VK_EXT_shader_demote_to_helper_invocation", |
| "VK_EXT_shader_image_atomic_int64", |
| "VK_EXT_shader_stencil_export", |
| "VK_EXT_subgroup_size_control", |
| "VK_EXT_swapchain_colorspace", |
| "VK_EXT_texel_buffer_alignment", |
| "VK_EXT_texture_compression_astc_hdr", |
| "VK_EXT_validation_features", |
| "VK_EXT_vertex_attribute_divisor", |
| "VK_EXT_vertex_input_dynamic_state", |
| "VK_EXT_ycbcr_2plane_444_formats", |
| "VK_EXT_ycbcr_image_arrays", |
| }; |
| |
| vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); |
| const vk::InstanceInterface& vki = context.getInstanceInterface(); |
| const std::vector<vk::VkExtensionProperties> deviceExtensions = vk::enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); |
| |
| for (const auto& extension : deviceExtensions) |
| { |
| const std::string extensionName(extension.extensionName); |
| |
| // this test applies only to VK_KHR_* and VK_EXT_* extensions |
| if (extensionName.find("VK_KHR") != 0 && extensionName.find("VK_EXT") != 0) |
| continue; |
| |
| if(extensions.find(extensionName)==extensions.end()) |
| TCU_THROW(TestError, extensionName + std::string(" extension is not allowed")); |
| } |
| |
| return tcu::TestStatus::pass("All implemented extensions are defined in specification"); |
| } |
| |
| } // anonymous |
| |
| tcu::TestCaseGroup* createSafetyCriticalAPITests (tcu::TestContext& testCtx) |
| { |
| de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "api", "Tests verifying Vulkan SC specific API")); |
| |
| addFunctionCase(group.get(), "forbidden_core_commands", "Verify existence of functions removed from Vulkan", forbiddenCoreCommands); |
| addFunctionCase(group.get(), "forbidden_core_extensions", "Verify existence of extensions removed from Vulkan", forbiddenCoreExtensions); |
| addFunctionCase(group.get(), "forbidden_promoted_commands", "Verify existence of promoted functions removed from Vulkan", forbiddenPromotedCommands); |
| addFunctionCase(group.get(), "forbidden_features", "Verify if specific device features are forbidden for Vulkan SC", forbiddenDeviceFeatures); |
| addFunctionCase(group.get(), "forbidden_properties", "Verify if specific device properties are forbidden for Vulkan SC", forbiddenDeviceProperties); |
| addFunctionCase(group.get(), "allowed_extensions", "Verify if extensions are allowed for Vulkan SC", allowedExtensions); |
| |
| return group.release(); |
| } |
| |
| } // sc |
| |
| } // vkt |
