From: Jan Mroczkowski Date: Thu, 12 Mar 2020 12:33:50 +0000 (+0100) Subject: Vulkan Portability support X-Git-Tag: upstream/1.3.5~1103 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=5534dd8f4996f5c37ca19b10299b00cac462b91e;p=platform%2Fupstream%2FVK-GL-CTS.git Vulkan Portability support Components: Framework, Vulkan Affects: dEQP-VK.* Change-Id: I90aac5ec24b4a47063d5d0faaa9f68edd65f1d58 --- diff --git a/external/vulkancts/modules/vulkan/amber/vktAmberTestCase.cpp b/external/vulkancts/modules/vulkan/amber/vktAmberTestCase.cpp index f4eb914..5ae05ee 100644 --- a/external/vulkancts/modules/vulkan/amber/vktAmberTestCase.cpp +++ b/external/vulkancts/modules/vulkan/amber/vktAmberTestCase.cpp @@ -185,6 +185,13 @@ void AmberTestCase::checkSupport(Context& ctx) const TCU_THROW(NotSupportedError, "Buffer format doesn't support required feature flags"); } } + + if (m_name == "triangle_fan" && + ctx.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !ctx.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } } class Delegate : public amber::Delegate diff --git a/external/vulkancts/modules/vulkan/api/vktApiCommandBuffersTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiCommandBuffersTests.cpp index afc76b1..2792624 100644 --- a/external/vulkancts/modules/vulkan/api/vktApiCommandBuffersTests.cpp +++ b/external/vulkancts/modules/vulkan/api/vktApiCommandBuffersTests.cpp @@ -4139,12 +4139,23 @@ void genComputeIncrementSource (SourceCollections& programCollection) programCollection.glslSources.add("compute_increment") << glu::ComputeSource(bufIncrement.str()); } -void genComputeIncrementSourceBadInheritance (SourceCollections& programCollection, BadInheritanceInfoCase testCase) +void genComputeIncrementSourceBadInheritance(SourceCollections& programCollection, BadInheritanceInfoCase testCase) { DE_UNREF(testCase); return genComputeIncrementSource(programCollection); } +void checkEventSupport (Context& context) +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && !context.getPortabilitySubsetFeatures().events) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Events are not supported by this implementation"); +} + +void checkEventSupport (Context& context, const VkCommandBufferLevel) +{ + checkEventSupport(context); +} + } // anonymous tcu::TestCaseGroup* createCommandBuffersTests (tcu::TestContext& testCtx) @@ -4158,30 +4169,30 @@ tcu::TestCaseGroup* createCommandBuffersTests (tcu::TestContext& testCtx) addFunctionCase (commandBuffersTests.get(), "pool_create_reset_bit", "", createPoolResetBitTest); addFunctionCase (commandBuffersTests.get(), "pool_reset_release_res", "", resetPoolReleaseResourcesBitTest); addFunctionCase (commandBuffersTests.get(), "pool_reset_no_flags_res", "", resetPoolNoFlagsTest); - addFunctionCase (commandBuffersTests.get(), "pool_reset_reuse", "", resetPoolReuseTest); + addFunctionCase (commandBuffersTests.get(), "pool_reset_reuse", "", checkEventSupport, resetPoolReuseTest); /* 19.2. Command Buffer Lifetime (5.2 in VK 1.0 Spec) */ addFunctionCase (commandBuffersTests.get(), "allocate_single_primary", "", allocatePrimaryBufferTest); addFunctionCase (commandBuffersTests.get(), "allocate_many_primary", "", allocateManyPrimaryBuffersTest); addFunctionCase (commandBuffersTests.get(), "allocate_single_secondary", "", allocateSecondaryBufferTest); addFunctionCase (commandBuffersTests.get(), "allocate_many_secondary", "", allocateManySecondaryBuffersTest); - addFunctionCase (commandBuffersTests.get(), "execute_small_primary", "", executePrimaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "execute_large_primary", "", executeLargePrimaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "reset_implicit", "", resetBufferImplicitlyTest); - addFunctionCase (commandBuffersTests.get(), "trim_command_pool", "", trimCommandPoolTest, VK_COMMAND_BUFFER_LEVEL_PRIMARY); - addFunctionCase (commandBuffersTests.get(), "trim_command_pool_secondary", "", trimCommandPoolTest, VK_COMMAND_BUFFER_LEVEL_SECONDARY); + addFunctionCase (commandBuffersTests.get(), "execute_small_primary", "", checkEventSupport, executePrimaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "execute_large_primary", "", checkEventSupport, executeLargePrimaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "reset_implicit", "", checkEventSupport, resetBufferImplicitlyTest); + addFunctionCase (commandBuffersTests.get(), "trim_command_pool", "", checkEventSupport, trimCommandPoolTest, VK_COMMAND_BUFFER_LEVEL_PRIMARY); + addFunctionCase (commandBuffersTests.get(), "trim_command_pool_secondary", "", checkEventSupport, trimCommandPoolTest, VK_COMMAND_BUFFER_LEVEL_SECONDARY); /* 19.3. Command Buffer Recording (5.3 in VK 1.0 Spec) */ - addFunctionCase (commandBuffersTests.get(), "record_single_primary", "", recordSinglePrimaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "record_many_primary", "", recordLargePrimaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "record_single_secondary", "", recordSingleSecondaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "record_many_secondary", "", recordLargeSecondaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "submit_twice_primary", "", submitPrimaryBufferTwiceTest); - addFunctionCase (commandBuffersTests.get(), "submit_twice_secondary", "", submitSecondaryBufferTwiceTest); - addFunctionCase (commandBuffersTests.get(), "record_one_time_submit_primary", "", oneTimeSubmitFlagPrimaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "record_one_time_submit_secondary", "", oneTimeSubmitFlagSecondaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "record_single_primary", "", checkEventSupport, recordSinglePrimaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "record_many_primary", "", checkEventSupport, recordLargePrimaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "record_single_secondary", "", checkEventSupport, recordSingleSecondaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "record_many_secondary", "", checkEventSupport, recordLargeSecondaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "submit_twice_primary", "", checkEventSupport, submitPrimaryBufferTwiceTest); + addFunctionCase (commandBuffersTests.get(), "submit_twice_secondary", "", checkEventSupport, submitSecondaryBufferTwiceTest); + addFunctionCase (commandBuffersTests.get(), "record_one_time_submit_primary", "", checkEventSupport, oneTimeSubmitFlagPrimaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "record_one_time_submit_secondary", "", checkEventSupport, oneTimeSubmitFlagSecondaryBufferTest); addFunctionCase (commandBuffersTests.get(), "render_pass_continue", "", renderPassContinueTest, true); addFunctionCase (commandBuffersTests.get(), "render_pass_continue_no_fb", "", renderPassContinueTest, false); - addFunctionCase (commandBuffersTests.get(), "record_simul_use_primary", "", simultaneousUsePrimaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "record_simul_use_secondary", "", simultaneousUseSecondaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "record_simul_use_primary", "", checkEventSupport, simultaneousUsePrimaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "record_simul_use_secondary", "", checkEventSupport, simultaneousUseSecondaryBufferTest); addFunctionCaseWithPrograms (commandBuffersTests.get(), "record_simul_use_secondary_one_primary", "", genComputeIncrementSource, simultaneousUseSecondaryBufferOnePrimaryBufferTest); addFunctionCaseWithPrograms (commandBuffersTests.get(), "record_simul_use_secondary_two_primary", "", genComputeIncrementSource, simultaneousUseSecondaryBufferTwoPrimaryBuffersTest); addFunctionCase (commandBuffersTests.get(), "record_query_precise_w_flag", "", recordBufferQueryPreciseWithFlagTest); @@ -4193,15 +4204,15 @@ tcu::TestCaseGroup* createCommandBuffersTests (tcu::TestContext& testCtx) addFunctionCaseWithPrograms (commandBuffersTests.get(), "bad_inheritance_info_invalid_type", "", genComputeIncrementSourceBadInheritance, badInheritanceInfoTest, BadInheritanceInfoCase::INVALID_STRUCTURE_TYPE); addFunctionCaseWithPrograms (commandBuffersTests.get(), "bad_inheritance_info_valid_nonsense_type", "", genComputeIncrementSourceBadInheritance, badInheritanceInfoTest, BadInheritanceInfoCase::VALID_NONSENSE_TYPE); /* 19.4. Command Buffer Submission (5.4 in VK 1.0 Spec) */ - addFunctionCase (commandBuffersTests.get(), "submit_count_non_zero", "", submitBufferCountNonZero); - addFunctionCase (commandBuffersTests.get(), "submit_count_equal_zero", "", submitBufferCountEqualZero); - addFunctionCase (commandBuffersTests.get(), "submit_wait_single_semaphore", "", submitBufferWaitSingleSemaphore); - addFunctionCase (commandBuffersTests.get(), "submit_wait_many_semaphores", "", submitBufferWaitManySemaphores); - addFunctionCase (commandBuffersTests.get(), "submit_null_fence", "", submitBufferNullFence); - addFunctionCase (commandBuffersTests.get(), "submit_two_buffers_one_buffer_null_with_fence", "", submitTwoBuffersOneBufferNullWithFence); + addFunctionCase (commandBuffersTests.get(), "submit_count_non_zero", "", checkEventSupport, submitBufferCountNonZero); + addFunctionCase (commandBuffersTests.get(), "submit_count_equal_zero", "", checkEventSupport, submitBufferCountEqualZero); + addFunctionCase (commandBuffersTests.get(), "submit_wait_single_semaphore", "", checkEventSupport, submitBufferWaitSingleSemaphore); + addFunctionCase (commandBuffersTests.get(), "submit_wait_many_semaphores", "", checkEventSupport, submitBufferWaitManySemaphores); + addFunctionCase (commandBuffersTests.get(), "submit_null_fence", "", checkEventSupport, submitBufferNullFence); + addFunctionCase (commandBuffersTests.get(), "submit_two_buffers_one_buffer_null_with_fence", "", checkEventSupport, submitTwoBuffersOneBufferNullWithFence); /* 19.5. Secondary Command Buffer Execution (5.6 in VK 1.0 Spec) */ - addFunctionCase (commandBuffersTests.get(), "secondary_execute", "", executeSecondaryBufferTest); - addFunctionCase (commandBuffersTests.get(), "secondary_execute_twice", "", executeSecondaryBufferTwiceTest); + addFunctionCase (commandBuffersTests.get(), "secondary_execute", "", checkEventSupport, executeSecondaryBufferTest); + addFunctionCase (commandBuffersTests.get(), "secondary_execute_twice", "", checkEventSupport, executeSecondaryBufferTwiceTest); /* 19.6. Commands Allowed Inside Command Buffers (? in VK 1.0 Spec) */ addFunctionCaseWithPrograms (commandBuffersTests.get(), "order_bind_pipeline", "", genComputeSource, orderBindPipelineTest); /* Verify untested transitions between command buffer states */ diff --git a/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp index 926fd7f..a715820 100644 --- a/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp +++ b/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp @@ -3926,6 +3926,20 @@ tcu::TestStatus testImageExportImportBindBind (Context& context, return tcu::TestStatus::pass("Pass"); } + +template void checkEvent (Context& context, const TestConfig) +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && !context.getPortabilitySubsetFeatures().events) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Events are not supported by this implementation"); +} + +template void checkSupport (Context& context, const TestConfig config) +{ + const Transference transference (getHandelTypeTransferences(config.externalType)); + if (transference == TRANSFERENCE_COPY) + checkEvent(context, config); +} + de::MovePtr createFenceTests (tcu::TestContext& testCtx, vk::VkExternalFenceHandleTypeFlagBits externalType) { const struct @@ -3957,13 +3971,13 @@ de::MovePtr createFenceTests (tcu::TestContext& testCtx, vk: addFunctionCase(fenceGroup.get(), std::string("create_win32_") + permanenceName, "Test creating fence with win32 properties.", testFenceWin32Create, config); } - addFunctionCase(fenceGroup.get(), std::string("import_twice_") + permanenceName, "Test importing fence twice.", testFenceImportTwice, config); - addFunctionCase(fenceGroup.get(), std::string("reimport_") + permanenceName, "Test importing again over previously imported fence.", testFenceImportReimport, config); - addFunctionCase(fenceGroup.get(), std::string("import_multiple_times_") + permanenceName, "Test importing fence multiple times.", testFenceMultipleImports, config); - addFunctionCase(fenceGroup.get(), std::string("signal_export_import_wait_") + permanenceName, "Test signaling, exporting, importing and waiting for the sempahore.", testFenceSignalExportImportWait, config); - addFunctionCase(fenceGroup.get(), std::string("signal_import_") + permanenceName, "Test signaling and importing the fence.", testFenceSignalImport, 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); + addFunctionCase(fenceGroup.get(), std::string("import_twice_") + permanenceName, "Test importing fence twice.", checkSupport, testFenceImportTwice, config); + addFunctionCase(fenceGroup.get(), std::string("reimport_") + permanenceName, "Test importing again over previously imported fence.", checkSupport, testFenceImportReimport, config); + addFunctionCase(fenceGroup.get(), std::string("import_multiple_times_") + permanenceName, "Test importing fence multiple times.", checkSupport, testFenceMultipleImports, config); + addFunctionCase(fenceGroup.get(), std::string("signal_export_import_wait_") + permanenceName, "Test signaling, exporting, importing and waiting for the sempahore.", checkEvent, testFenceSignalExportImportWait, config); + addFunctionCase(fenceGroup.get(), std::string("signal_import_") + permanenceName, "Test signaling and importing the fence.", checkSupport, testFenceSignalImport, config); + addFunctionCase(fenceGroup.get(), std::string("reset_") + permanenceName, "Test resetting the fence.", checkEvent, testFenceReset, config); + addFunctionCase(fenceGroup.get(), std::string("transference_") + permanenceName, "Test fences transference.", checkEvent, testFenceTransference, config); if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT) { @@ -3974,12 +3988,12 @@ de::MovePtr createFenceTests (tcu::TestContext& testCtx, vk: || 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); + addFunctionCase(fenceGroup.get(), std::string("export_multiple_times_") + permanenceName, "Test exporting fence multiple times.", checkSupport, testFenceMultipleExports, config); - addFunctionCase(fenceGroup.get(), std::string("dup_") + permanenceName, "Test calling dup() on exported fence.", testFenceFdDup, config); - addFunctionCase(fenceGroup.get(), std::string("dup2_") + permanenceName, "Test calling dup2() on exported fence.", testFenceFdDup2, config); - addFunctionCase(fenceGroup.get(), std::string("dup3_") + permanenceName, "Test calling dup3() on exported fence.", testFenceFdDup3, config); - addFunctionCase(fenceGroup.get(), std::string("send_over_socket_") + permanenceName, "Test sending fence fd over socket.", testFenceFdSendOverSocket, config); + addFunctionCase(fenceGroup.get(), std::string("dup_") + permanenceName, "Test calling dup() on exported fence.", checkSupport, testFenceFdDup, config); + addFunctionCase(fenceGroup.get(), std::string("dup2_") + permanenceName, "Test calling dup2() on exported fence.", checkSupport, testFenceFdDup2, config); + addFunctionCase(fenceGroup.get(), std::string("dup3_") + permanenceName, "Test calling dup3() on exported fence.", checkSupport, testFenceFdDup3, config); + addFunctionCase(fenceGroup.get(), std::string("send_over_socket_") + permanenceName, "Test sending fence fd over socket.", checkSupport, testFenceFdSendOverSocket, config); } if (getHandelTypeTransferences(externalType) == TRANSFERENCE_REFERENCE) @@ -4339,12 +4353,12 @@ de::MovePtr createSemaphoreTests (tcu::TestContext& testCtx, addFunctionCase(semaphoreGroup.get(), std::string("create_win32_") + permanenceName, "Test creating semaphore with win32 properties.", testSemaphoreWin32Create, config); } - addFunctionCase(semaphoreGroup.get(), std::string("import_twice_") + permanenceName, "Test importing semaphore twice.", testSemaphoreImportTwice, config); - addFunctionCase(semaphoreGroup.get(), std::string("reimport_") + permanenceName, "Test importing again over previously imported semaphore.", testSemaphoreImportReimport, config); - addFunctionCase(semaphoreGroup.get(), std::string("import_multiple_times_") + permanenceName, "Test importing semaphore multiple times.", testSemaphoreMultipleImports, config); - addFunctionCase(semaphoreGroup.get(), std::string("signal_export_import_wait_") + permanenceName, "Test signaling, exporting, importing and waiting for the sempahore.", testSemaphoreSignalExportImportWait, 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); + addFunctionCase(semaphoreGroup.get(), std::string("import_twice_") + permanenceName, "Test importing semaphore twice.", checkSupport, testSemaphoreImportTwice, config); + addFunctionCase(semaphoreGroup.get(), std::string("reimport_") + permanenceName, "Test importing again over previously imported semaphore.", checkSupport, testSemaphoreImportReimport, config); + addFunctionCase(semaphoreGroup.get(), std::string("import_multiple_times_") + permanenceName, "Test importing semaphore multiple times.", checkSupport, testSemaphoreMultipleImports, config); + addFunctionCase(semaphoreGroup.get(), std::string("signal_export_import_wait_") + permanenceName, "Test signaling, exporting, importing and waiting for the sempahore.", checkEvent, testSemaphoreSignalExportImportWait, config); + addFunctionCase(semaphoreGroup.get(), std::string("signal_import_") + permanenceName, "Test signaling and importing the semaphore.", checkSupport, testSemaphoreSignalImport, config); + addFunctionCase(semaphoreGroup.get(), std::string("transference_") + permanenceName, "Test semaphores transference.", checkEvent, testSemaphoreTransference, config); if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT) { @@ -4356,19 +4370,19 @@ de::MovePtr createSemaphoreTests (tcu::TestContext& testCtx, || 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); + addFunctionCase(semaphoreGroup.get(), std::string("export_multiple_times_") + permanenceName, "Test exporting semaphore multiple times.", checkSupport, testSemaphoreMultipleExports, config); - addFunctionCase(semaphoreGroup.get(), std::string("dup_") + permanenceName, "Test calling dup() on exported semaphore.", testSemaphoreFdDup, config); - addFunctionCase(semaphoreGroup.get(), std::string("dup2_") + permanenceName, "Test calling dup2() on exported semaphore.", testSemaphoreFdDup2, config); - addFunctionCase(semaphoreGroup.get(), std::string("dup3_") + permanenceName, "Test calling dup3() on exported semaphore.", testSemaphoreFdDup3, config); - addFunctionCase(semaphoreGroup.get(), std::string("send_over_socket_") + permanenceName, "Test sending semaphore fd over socket.", testSemaphoreFdSendOverSocket, config); + addFunctionCase(semaphoreGroup.get(), std::string("dup_") + permanenceName, "Test calling dup() on exported semaphore.", checkSupport, testSemaphoreFdDup, config); + addFunctionCase(semaphoreGroup.get(), std::string("dup2_") + permanenceName, "Test calling dup2() on exported semaphore.", checkSupport, testSemaphoreFdDup2, config); + addFunctionCase(semaphoreGroup.get(), std::string("dup3_") + permanenceName, "Test calling dup3() on exported semaphore.", checkSupport, testSemaphoreFdDup3, config); + addFunctionCase(semaphoreGroup.get(), std::string("send_over_socket_") + permanenceName, "Test sending semaphore fd over socket.", checkSupport, testSemaphoreFdSendOverSocket, config); } if (getHandelTypeTransferences(externalType) == TRANSFERENCE_REFERENCE) { addFunctionCase(semaphoreGroup.get(), std::string("signal_wait_import_") + permanenceName, "Test signaling and then waiting for the the sepmahore.", testSemaphoreSignalWaitImport, config); addFunctionCase(semaphoreGroup.get(), std::string("export_signal_import_wait_") + permanenceName, "Test exporting, signaling, importing and waiting for the semaphore.", testSemaphoreExportSignalImportWait, config); - addFunctionCase(semaphoreGroup.get(), std::string("export_import_signal_wait_") + permanenceName, "Test exporting, importing, signaling and waiting for the semaphore.", testSemaphoreExportImportSignalWait, config); + addFunctionCase(semaphoreGroup.get(), std::string("export_import_signal_wait_") + permanenceName, "Test exporting, importing, signaling and waiting for the semaphore.", checkEvent, testSemaphoreExportImportSignalWait, config); } } diff --git a/external/vulkancts/modules/vulkan/api/vktApiNullHandleTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiNullHandleTests.cpp index 609106e..99d5b7d 100644 --- a/external/vulkancts/modules/vulkan/api/vktApiNullHandleTests.cpp +++ b/external/vulkancts/modules/vulkan/api/vktApiNullHandleTests.cpp @@ -265,6 +265,12 @@ tcu::TestStatus test (Context& context) } } +void checkEventSupport (Context& context) +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && !context.getPortabilitySubsetFeatures().events) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Events are not supported by this implementation"); +} + void addTestsToGroup (tcu::TestCaseGroup* group) { addFunctionCase(group, "destroy_buffer", "", test); @@ -273,7 +279,7 @@ void addTestsToGroup (tcu::TestCaseGroup* group) addFunctionCase(group, "destroy_descriptor_pool", "", test); addFunctionCase(group, "destroy_descriptor_set_layout", "", test); addFunctionCase(group, "destroy_device", "", test); - addFunctionCase(group, "destroy_event", "", test); + addFunctionCase(group, "destroy_event", "", checkEventSupport, test); addFunctionCase(group, "destroy_fence", "", test); addFunctionCase(group, "destroy_framebuffer", "", test); addFunctionCase(group, "destroy_image", "", test); diff --git a/external/vulkancts/modules/vulkan/api/vktApiObjectManagementTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiObjectManagementTests.cpp index fdd6bb8..0f5a6d7 100644 --- a/external/vulkancts/modules/vulkan/api/vktApiObjectManagementTests.cpp +++ b/external/vulkancts/modules/vulkan/api/vktApiObjectManagementTests.cpp @@ -3090,6 +3090,20 @@ void addCases (tcu::TestCaseGroup *group, const CaseDescription& cases) addFunctionCase(group, cur->name, "", cases.function, cur->parameters); } +void checkEventSupport (Context& context, const Event::Parameters) +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && !context.getPortabilitySubsetFeatures().events) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Events are not supported by this implementation"); +} + +// specialization for Event +template<> +void addCases (tcu::TestCaseGroup* group, const CaseDescription& cases) +{ + for (const NamedParameters* cur = cases.paramsBegin; cur != cases.paramsEnd; ++cur) + addFunctionCase(group, cur->name, "", checkEventSupport, cases.function, cur->parameters); +} + template void addCasesWithProgs (tcu::TestCaseGroup *group, const CaseDescription& cases) { diff --git a/external/vulkancts/modules/vulkan/clipping/vktClippingTests.cpp b/external/vulkancts/modules/vulkan/clipping/vktClippingTests.cpp index 178b699..7d61b11 100644 --- a/external/vulkancts/modules/vulkan/clipping/vktClippingTests.cpp +++ b/external/vulkancts/modules/vulkan/clipping/vktClippingTests.cpp @@ -1473,6 +1473,16 @@ tcu::TestStatus testComplementarity (Context& context, const int numClipDistance } // ClipDistanceComplementarity ns +void checkTopologySupport(Context& context, const VkPrimitiveTopology topology) +{ + if (topology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } +} + void addClippingTests (tcu::TestCaseGroup* clippingTestsGroup) { tcu::TestContext& testCtx = clippingTestsGroup->getTestContext(); @@ -1503,7 +1513,7 @@ void addClippingTests (tcu::TestCaseGroup* clippingTestsGroup) for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); ++caseNdx) addFunctionCaseWithPrograms( - group.get(), getPrimitiveTopologyShortName(cases[caseNdx]), "", initPrograms, testPrimitivesInside, cases[caseNdx]); + group.get(), getPrimitiveTopologyShortName(cases[caseNdx]), "", checkTopologySupport, initPrograms, testPrimitivesInside, cases[caseNdx]); clipVolumeGroup->addChild(group.release()); } @@ -1514,7 +1524,7 @@ void addClippingTests (tcu::TestCaseGroup* clippingTestsGroup) for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); ++caseNdx) addFunctionCaseWithPrograms( - group.get(), getPrimitiveTopologyShortName(cases[caseNdx]), "", initPrograms, testPrimitivesOutside, cases[caseNdx]); + group.get(), getPrimitiveTopologyShortName(cases[caseNdx]), "", checkTopologySupport, initPrograms, testPrimitivesOutside, cases[caseNdx]); clipVolumeGroup->addChild(group.release()); } @@ -1525,7 +1535,7 @@ void addClippingTests (tcu::TestCaseGroup* clippingTestsGroup) for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); ++caseNdx) addFunctionCaseWithPrograms( - group.get(), getPrimitiveTopologyShortName(cases[caseNdx]), "", initPrograms, testPrimitivesDepthClamp, cases[caseNdx]); + group.get(), getPrimitiveTopologyShortName(cases[caseNdx]), "", checkTopologySupport, initPrograms, testPrimitivesDepthClamp, cases[caseNdx]); clipVolumeGroup->addChild(group.release()); } @@ -1536,7 +1546,7 @@ void addClippingTests (tcu::TestCaseGroup* clippingTestsGroup) for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); ++caseNdx) addFunctionCaseWithPrograms( - group.get(), getPrimitiveTopologyShortName(cases[caseNdx]), "", initPrograms, testPrimitivesDepthClip, cases[caseNdx]); + group.get(), getPrimitiveTopologyShortName(cases[caseNdx]), "", checkTopologySupport, initPrograms, testPrimitivesDepthClip, cases[caseNdx]); clipVolumeGroup->addChild(group.release()); } diff --git a/external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalDrawAndClearTests.cpp b/external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalDrawAndClearTests.cpp index 40124dd..c8b886d 100644 --- a/external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalDrawAndClearTests.cpp +++ b/external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalDrawAndClearTests.cpp @@ -1400,6 +1400,17 @@ void checkSupport (Context& context) context.requireDeviceFunctionality("VK_EXT_conditional_rendering"); } +void checkFan (Context& context) +{ + checkSupport(context); + + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } +} + } // unnamed namespace ConditionalRenderingDrawAndClearTests::ConditionalRenderingDrawAndClearTests (tcu::TestContext &testCtx) @@ -1428,10 +1439,10 @@ void ConditionalRenderingDrawAndClearTests::init (void) depth->addChild(new InstanceFactory1WithSupport(m_testCtx, tcu::NODETYPE_SELF_VALIDATE, "clear_attachment_twice_" + generateClearTestName(clearDepthTwiceGrid[testNdx]), "Depth clear test.", clearDepthTwiceGrid[testNdx], checkSupport)); for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(drawTestGrid); testNdx++) - draw->addChild(new InstanceFactory1WithSupport(m_testCtx, tcu::NODETYPE_SELF_VALIDATE, "case_" + de::toString(testNdx), "Draw test.", AddProgramsDraw(), drawTestGrid[testNdx], checkSupport)); + draw->addChild(new InstanceFactory1WithSupport(m_testCtx, tcu::NODETYPE_SELF_VALIDATE, "case_" + de::toString(testNdx), "Draw test.", AddProgramsDraw(), drawTestGrid[testNdx], checkFan)); - draw->addChild(new InstanceFactory1WithSupport(m_testCtx, tcu::NODETYPE_SELF_VALIDATE, "update_with_rendering_no_discard", "Draw test.", AddProgramsUpdateBufferUsingRendering(), true, checkSupport)); - draw->addChild(new InstanceFactory1WithSupport(m_testCtx, tcu::NODETYPE_SELF_VALIDATE, "update_with_rendering_discard", "Draw test.", AddProgramsUpdateBufferUsingRendering(), false, checkSupport)); + draw->addChild(new InstanceFactory1WithSupport(m_testCtx, tcu::NODETYPE_SELF_VALIDATE, "update_with_rendering_no_discard", "Draw test.", AddProgramsUpdateBufferUsingRendering(), true, checkFan)); + draw->addChild(new InstanceFactory1WithSupport(m_testCtx, tcu::NODETYPE_SELF_VALIDATE, "update_with_rendering_discard", "Draw test.", AddProgramsUpdateBufferUsingRendering(), false, checkFan)); clear->addChild(color); clear->addChild(depth); diff --git a/external/vulkancts/modules/vulkan/draw/vktBasicDrawTests.cpp b/external/vulkancts/modules/vulkan/draw/vktBasicDrawTests.cpp index 120235d..a894ab2 100644 --- a/external/vulkancts/modules/vulkan/draw/vktBasicDrawTests.cpp +++ b/external/vulkancts/modules/vulkan/draw/vktBasicDrawTests.cpp @@ -578,6 +578,13 @@ void DrawTestCase::checkSupport (Context& context) const { context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER); } + + if (m_data.topology == vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } } template diff --git a/external/vulkancts/modules/vulkan/draw/vktDrawInstancedTests.cpp b/external/vulkancts/modules/vulkan/draw/vktDrawInstancedTests.cpp index f0df4a2..ad28aff 100644 --- a/external/vulkancts/modules/vulkan/draw/vktDrawInstancedTests.cpp +++ b/external/vulkancts/modules/vulkan/draw/vktDrawInstancedTests.cpp @@ -310,6 +310,13 @@ public: TCU_THROW(NotSupportedError, "Implementation does not support multiview feature"); } } + + if (m_params.topology == vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } } TestInstance* createInstance (Context& context) const diff --git a/external/vulkancts/modules/vulkan/geometry/vktGeometryInputGeometryShaderTests.cpp b/external/vulkancts/modules/vulkan/geometry/vktGeometryInputGeometryShaderTests.cpp index 6ec246d..d748e70 100644 --- a/external/vulkancts/modules/vulkan/geometry/vktGeometryInputGeometryShaderTests.cpp +++ b/external/vulkancts/modules/vulkan/geometry/vktGeometryInputGeometryShaderTests.cpp @@ -143,6 +143,13 @@ GeometryExpanderRenderTest::GeometryExpanderRenderTest (TestContext& testCtx, co void GeometryExpanderRenderTest::checkSupport (Context& context) const { context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER); + + if (m_primitiveType == vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } } void GeometryExpanderRenderTest::initPrograms (SourceCollections& sourceCollections) const diff --git a/external/vulkancts/modules/vulkan/geometry/vktGeometryLayeredRenderingTests.cpp b/external/vulkancts/modules/vulkan/geometry/vktGeometryLayeredRenderingTests.cpp index 8d43032..5a4f5e2 100644 --- a/external/vulkancts/modules/vulkan/geometry/vktGeometryLayeredRenderingTests.cpp +++ b/external/vulkancts/modules/vulkan/geometry/vktGeometryLayeredRenderingTests.cpp @@ -1809,8 +1809,16 @@ void checkSupport (Context& context, const TestParams params) context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER); if (params.image.viewType == VK_IMAGE_VIEW_TYPE_3D) + { context.requireDeviceFunctionality("VK_KHR_maintenance1"); + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().imageView2DOn3DImage) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Implementation does not support 2D or 2D array image view to be created on a 3D VkImage"); + } + } + if (params.testType == TEST_TYPE_SECONDARY_CMD_BUFFER) context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_FRAGMENT_STORES_AND_ATOMICS); } diff --git a/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp index 77f9212..7143c9d 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp +++ b/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp @@ -862,6 +862,16 @@ TestInstance* ImageTranscodingCase::createInstance (Context& context) const if (differenceFound) { + const auto portabilitySubsetFeatures = context.getPortabilitySubsetFeatures(); + if (!portabilitySubsetFeatures.imageViewFormatReinterpretation) + { + tcu::TextureFormat textureImageFormat = vk::mapVkFormat(m_parameters.featuredFormat); + tcu::TextureFormat textureViewFormat = vk::mapVkFormat(featurelessFormat); + + if (tcu::getTextureFormatBitDepth(textureImageFormat) != tcu::getTextureFormatBitDepth(textureViewFormat)) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Format must not contain a different number of bits in each component, than the format of the VkImage"); + } + TestParameters calculatedParameters = { m_parameters.operation, // Operation operation diff --git a/external/vulkancts/modules/vulkan/memory/vktMemoryExternalMemoryHostTests.cpp b/external/vulkancts/modules/vulkan/memory/vktMemoryExternalMemoryHostTests.cpp index 6888aed..d86c280 100644 --- a/external/vulkancts/modules/vulkan/memory/vktMemoryExternalMemoryHostTests.cpp +++ b/external/vulkancts/modules/vulkan/memory/vktMemoryExternalMemoryHostTests.cpp @@ -1055,6 +1055,13 @@ void checkSupport (Context& context) context.requireDeviceFunctionality("VK_EXT_external_memory_host"); } +void checkEvent (Context& context) +{ + checkSupport(context); + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && !context.getPortabilitySubsetFeatures().events) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Events are not supported by this implementation"); +} + } // unnamed namespace tcu::TestCaseGroup* createMemoryExternalMemoryHostTests (tcu::TestContext& testCtx) @@ -1100,7 +1107,7 @@ tcu::TestCaseGroup* createMemoryExternalMemoryHostTests (tcu::TestContext& testC synchronization->addChild(new InstanceFactory1WithSupport (testCtx, tcu::NODETYPE_SELF_VALIDATE, "synchronization", "synchronization", AddPrograms(), - TestParams(testFormats[0].format, true), checkSupport)); + TestParams(testFormats[0].format, true), checkEvent)); group->addChild(synchronization.release()); return group.release(); } diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineBlendTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineBlendTests.cpp index a0496bd..e14cb8b 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineBlendTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineBlendTests.cpp @@ -438,6 +438,25 @@ void BlendTest::checkSupport (Context& context) const { if (!isSupportedBlendFormat(context.getInstanceInterface(), context.getPhysicalDevice(), m_colorFormat)) throw tcu::NotSupportedError(std::string("Unsupported color blending format: ") + getFormatName(m_colorFormat)); + + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().constantAlphaColorBlendFactors) + { + int quadNdx = 0; + for (; quadNdx < BlendTest::QUAD_COUNT; quadNdx++) + { + const VkPipelineColorBlendAttachmentState& blendState = m_blendStates[quadNdx]; + if (blendState.srcColorBlendFactor == VK_BLEND_FACTOR_CONSTANT_ALPHA || + blendState.dstColorBlendFactor == VK_BLEND_FACTOR_CONSTANT_ALPHA || + blendState.srcColorBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA || + blendState.dstColorBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA) + { + break; + } + } + if (quadNdx < BlendTest::QUAD_COUNT) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Constant alpha color blend factors are not supported by this implementation"); + } } void BlendTest::initPrograms (SourceCollections& sourceCollections) const diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineImageSamplingInstance.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineImageSamplingInstance.cpp index 46ef651..1eae7a0 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineImageSamplingInstance.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineImageSamplingInstance.cpp @@ -325,6 +325,20 @@ void checkSupportImageSamplingInstance (Context& context, ImageSamplingInstanceP if (params.allocationKind == ALLOCATION_KIND_DEDICATED) context.requireDeviceFunctionality("VK_KHR_dedicated_allocation"); + + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset")) + { + const auto portabilitySubsetFeatures = context.getPortabilitySubsetFeatures(); + const auto componentMapping = params.componentMapping; + if (!portabilitySubsetFeatures.imageViewFormatSwizzle && + ((componentMapping.r != VK_COMPONENT_SWIZZLE_IDENTITY) || + (componentMapping.g != VK_COMPONENT_SWIZZLE_IDENTITY) || + (componentMapping.b != VK_COMPONENT_SWIZZLE_IDENTITY) || + (componentMapping.a != VK_COMPONENT_SWIZZLE_IDENTITY))) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Implementation does not support remapping format components"); + } + } } ImageSamplingInstance::ImageSamplingInstance (Context& context, diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineInputAssemblyTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineInputAssemblyTests.cpp index 9af8969..1eee007 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineInputAssemblyTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineInputAssemblyTests.cpp @@ -244,6 +244,13 @@ void InputAssemblyTest::checkSupport (Context& context) const default: break; } + + if (m_primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } } TestInstance* InputAssemblyTest::createInstance (Context& context) const diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleBaseResolve.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleBaseResolve.cpp index 67046b7..7483b86 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleBaseResolve.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleBaseResolve.cpp @@ -44,6 +44,17 @@ using namespace vk; tcu::TestStatus MSInstanceBaseResolve::iterate (void) { + // cases creating this tests are defined using templates and we do not have easy access + // to image type - to do this check in checkSupport bigger reffactoring would be needed + if (m_context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !m_context.getPortabilitySubsetFeatures().multisampleArrayImage && + (m_imageType == IMAGE_TYPE_2D_ARRAY) && + (m_imageMSParams.numSamples != VK_SAMPLE_COUNT_1_BIT) && + (m_imageMSParams.imageSize.z() != 1)) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Implementation does not support image array with multiple samples per texel"); + } + const InstanceInterface& instance = m_context.getInstanceInterface(); const DeviceInterface& deviceInterface = m_context.getDeviceInterface(); const VkDevice device = m_context.getDevice(); diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleImageTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleImageTests.cpp index ef4efb3..edc00c1 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleImageTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleImageTests.cpp @@ -900,6 +900,13 @@ void checkSupport (Context& context, const CaseDef caseDef) const VkImageUsageFlags colorImageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; checkImageFormatRequirements(context.getInstanceInterface(), context.getPhysicalDevice(), caseDef.numSamples, caseDef.colorFormat, colorImageUsage); + + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().multisampleArrayImage && + (caseDef.numSamples != VK_SAMPLE_COUNT_1_BIT) && (caseDef.numLayers != 1)) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Implementation does not support image array with multiple samples per texel"); + } } tcu::TestStatus test (Context& context, const CaseDef caseDef) diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleInterpolationTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleInterpolationTests.cpp index e3ed15f..60c183f 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleInterpolationTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleInterpolationTests.cpp @@ -87,7 +87,7 @@ public: void init (void); void initPrograms (vk::SourceCollections& programCollection) const; - virtual void checkSupport (Context&) const {} + void checkSupport (Context& context) const; TestInstance* createInstance (Context& context) const; static MultisampleCaseBase* createCase (tcu::TestContext& testCtx, const std::string& name, @@ -95,6 +95,18 @@ public: }; template +void MSCase::checkSupport (Context& context) const +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().shaderSampleRateInterpolationFunctions) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Shader sample rate interpolation functions are not supported by this implementation"); + } + + context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING); +} + +template MultisampleCaseBase* MSCase::createCase (tcu::TestContext& testCtx, const std::string& name, const ImageMSParams& imageMSParams) { return new MSCase(testCtx, name, imageMSParams); @@ -291,11 +303,6 @@ template<> void MSCase::initPrograms (v programCollection.glslSources.add("fragment_shader") << glu::FragmentSource(fs.str()); } -template<> void MSCase::checkSupport (Context& context) const -{ - context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING); -} - template<> TestInstance* MSCase::createInstance (Context& context) const { return new MSInstance(context, m_imageMSParams); @@ -418,11 +425,6 @@ template<> void MSCase::initPrograms (vk: programCollection.glslSources.add("fragment_shader") << glu::FragmentSource(fs.str()); } -template<> void MSCase::checkSupport (Context& context) const -{ - context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING); -} - template<> TestInstance* MSCase::createInstance (Context& context) const { return new MSInstance(context, m_imageMSParams); @@ -492,11 +494,6 @@ template<> void MSCase::initPrograms ( programCollection.glslSources.add("fragment_shader") << glu::FragmentSource(fs.str()); } -template<> void MSCase::checkSupport (Context& context) const -{ - context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING); -} - template<> TestInstance* MSCase::createInstance (Context& context) const { return new MSInstance(context, m_imageMSParams); @@ -601,11 +598,6 @@ template<> void MSCase::initPrograms (vk:: programCollection.glslSources.add("fragment_shader") << glu::FragmentSource(fs.str()); } -template<> void MSCase::checkSupport (Context& context) const -{ - context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING); -} - template<> TestInstance* MSCase::createInstance (Context& context) const { return new MSInstance(context, m_imageMSParams); @@ -710,11 +702,6 @@ template<> void MSCase::initPrograms (vk programCollection.glslSources.add("fragment_shader") << glu::FragmentSource(fs.str()); } -template<> void MSCase::checkSupport (Context& context) const -{ - context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING); -} - template<> TestInstance* MSCase::createInstance (Context& context) const { return new MSInstance(context, m_imageMSParams); @@ -790,11 +777,6 @@ template<> void MSCase::initPrograms (vk:: programCollection.glslSources.add("fragment_shader") << glu::FragmentSource(fs.str()); } -template<> void MSCase::checkSupport (Context& context) const -{ - context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING); -} - template<> TestInstance* MSCase::createInstance (Context& context) const { return new MSInstance(context, m_imageMSParams); @@ -901,11 +883,6 @@ template<> void MSCase::initPrograms (v programCollection.glslSources.add("fragment_shader") << glu::FragmentSource(fs.str()); } -template<> void MSCase::checkSupport (Context& context) const -{ - context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING); -} - template<> TestInstance* MSCase::createInstance (Context& context) const { return new MSInstance(context, m_imageMSParams); @@ -1020,6 +997,10 @@ template<> void MSCase::initPrograms (vk programCollection.glslSources.add("fragment_shader") << glu::FragmentSource(fs.str()); } +template<> void MSCase::checkSupport (Context&) const +{ +} + template<> TestInstance* MSCase::createInstance (Context& context) const { return new MSInstance(context, m_imageMSParams); diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleSampleLocationsExtTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleSampleLocationsExtTests.cpp index 80861fa..421f367 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleSampleLocationsExtTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineMultisampleSampleLocationsExtTests.cpp @@ -1795,6 +1795,12 @@ void checkSupportDrawTests (Context& context, const TestParams params) // Are we allowed to modify the sample pattern within the same subpass? if (params.drawIn == TEST_DRAW_IN_SAME_SUBPASS && ((params.options & TEST_OPTION_SAME_PATTERN_BIT) == 0) && !getSampleLocationsPropertiesEXT(context).variableSampleLocations) TCU_THROW(NotSupportedError, "VkPhysicalDeviceSampleLocationsPropertiesEXT: variableSampleLocations not supported"); + + if (TEST_OPTION_WAIT_EVENTS_BIT & params.options && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && !context.getPortabilitySubsetFeatures().events) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Events are not supported by this implementation"); + } } const char* getString (const TestImageAspect aspect) diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineRenderToImageTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineRenderToImageTests.cpp index c858f98..a13b8df 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineRenderToImageTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineRenderToImageTests.cpp @@ -1219,7 +1219,15 @@ tcu::TestStatus testWithSizeReduction (Context& context, const CaseDef& caseDef) void checkImageViewTypeRequirements (Context& context, const VkImageViewType viewType) { if (viewType == VK_IMAGE_VIEW_TYPE_3D) + { + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().imageView2DOn3DImage) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Implementation does not support 2D or 2D array image view to be created on a 3D VkImage"); + } + context.requireDeviceFunctionality("VK_KHR_maintenance1"); + } if (viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_IMAGE_CUBE_ARRAY); diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineSamplerTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineSamplerTests.cpp index 526a56e..7496122 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineSamplerTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineSamplerTests.cpp @@ -223,6 +223,7 @@ public: bool separateStencilUsage); virtual ~SamplerLodTest (void) {} virtual VkSamplerCreateInfo getSamplerCreateInfo (void) const; + virtual void checkSupport (Context& context) const; private: VkSamplerMipmapMode m_mipmapMode; @@ -231,6 +232,17 @@ private: float m_mipLodBias; }; +void SamplerLodTest::checkSupport (Context& context) const +{ + SamplerTest::checkSupport(context); + + if (m_mipLodBias != 0.0f && context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().samplerMipLodBias) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Sampler mipmap LOD bias is not supported by this implementation"); + } +} + class SamplerAddressModesTest : public SamplerTest { public: diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineStencilTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineStencilTests.cpp index 6837dbb..1937f31 100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineStencilTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineStencilTests.cpp @@ -291,6 +291,9 @@ void StencilTest::checkSupport (Context& context) const if (m_separateDepthStencilLayouts && !context.isDeviceFunctionalitySupported("VK_KHR_separate_depth_stencil_layouts")) TCU_THROW(NotSupportedError, "VK_KHR_separate_depth_stencil_layouts is not supported"); + + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && !context.getPortabilitySubsetFeatures().separateStencilMaskRef) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Separate stencil mask references are not supported by this implementation"); } TestInstance* StencilTest::createInstance (Context& context) const diff --git a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolStatisticsTests.cpp b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolStatisticsTests.cpp index 258f7d2..2e80f51 100644 --- a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolStatisticsTests.cpp +++ b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolStatisticsTests.cpp @@ -2603,6 +2603,16 @@ public: m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec())); } + void checkSupport (vkt::Context& context) const + { + if (m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } + } + vkt::TestInstance* createInstance (vkt::Context& context) const { return new Instance(context, m_data, m_parametersGraphic, m_drawRepeats); diff --git a/external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp b/external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp index 80fc096..ea7eef0 100644 --- a/external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp +++ b/external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp @@ -3017,6 +3017,7 @@ public: { return new CullingTestInstance(context, m_cullMode, m_primitiveTopology, m_frontFace, m_polygonMode); } + void checkSupport (Context& context) const; protected: const VkCullModeFlags m_cullMode; const VkPrimitiveTopology m_primitiveTopology; @@ -3024,6 +3025,18 @@ protected: const VkPolygonMode m_polygonMode; }; +void CullingTestCase::checkSupport (Context& context) const +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset")) + { + const VkPhysicalDevicePortabilitySubsetFeaturesKHR& subsetFeatures = context.getPortabilitySubsetFeatures(); + if (m_polygonMode == VK_POLYGON_MODE_POINT && !subsetFeatures.pointPolygons) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Point polygons are not supported by this implementation"); + if (m_primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && !subsetFeatures.triangleFans) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } +} + class DiscardTestInstance : public BaseRenderingTestInstance { public: @@ -3494,6 +3507,11 @@ public: { if (m_queryFragmentShaderInvocations) context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_PIPELINE_STATISTICS_QUERY); + + if (m_primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); } protected: @@ -3733,6 +3751,16 @@ public: { return new TriangleInterpolationTestInstance(context, m_primitiveTopology, m_flags, m_sampleCount); } + + virtual void checkSupport (Context& context) const + { + if (m_primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } + } protected: const VkPrimitiveTopology m_primitiveTopology; const int m_flags; diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassFragmentDensityMapTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassFragmentDensityMapTests.cpp index 9959612..96e8961 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassFragmentDensityMapTests.cpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassFragmentDensityMapTests.cpp @@ -1217,6 +1217,13 @@ void FragmentDensityMapTest::checkSupport(Context& context) const if ((imageFormatProperties.sampleCounts & m_testParams.colorSamples) == 0) TCU_THROW(NotSupportedError, "Color image type not supported"); + + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().multisampleArrayImage && + (m_testParams.colorSamples != VK_SAMPLE_COUNT_1_BIT) && (m_testParams.viewCount != 1)) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Implementation does not support image array with multiple samples per texel"); + } } FragmentDensityMapTestInstance::FragmentDensityMapTestInstance(Context& context, diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp index 4904ffb..8df2b9c 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp @@ -2576,6 +2576,16 @@ struct Programs } }; +void checkSupport(Context& context, TestConfig config) +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().multisampleArrayImage && + (config.sampleCount != VK_SAMPLE_COUNT_1_BIT) && (config.layerCount != 1)) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Implementation does not support image array with multiple samples per texel"); + } +} + std::string formatToName (VkFormat format) { const std::string formatStr = de::toString(format); @@ -2682,7 +2692,7 @@ void initTests (tcu::TestCaseGroup* group, RenderPassType renderPassType) renderPassType }; - formatGroup->addChild(new InstanceFactory1(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName.c_str(), testName.c_str(), testConfig)); + formatGroup->addChild(new InstanceFactory1WithSupport, Programs>(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName.c_str(), testName.c_str(), testConfig, typename FunctionSupport1::Args(checkSupport, testConfig))); // MaxAttachmenstsRenderPassTest is ment to test extreme cases where applications might consume all available on-chip // memory. This is achieved by using maxColorAttachments attachments and two subpasses, but during test creation we diff --git a/external/vulkancts/modules/vulkan/shaderexecutor/vktAtomicOperationTests.cpp b/external/vulkancts/modules/vulkan/shaderexecutor/vktAtomicOperationTests.cpp index b45b561..24ca1d3 100644 --- a/external/vulkancts/modules/vulkan/shaderexecutor/vktAtomicOperationTests.cpp +++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktAtomicOperationTests.cpp @@ -1000,6 +1000,8 @@ void AtomicOperationCase::checkSupport (Context& ctx) const default: DE_FATAL("Unsupported shader type"); } + + checkSupportShader(ctx, m_shaderType.getType()); } void AtomicOperationCase::createShaderSpec (void) diff --git a/external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp b/external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp index cf9d34b..1315427 100644 --- a/external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp +++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp @@ -185,6 +185,8 @@ public: generateSources(m_shaderType, m_shaderSpec, programCollection); } + void checkSupport (Context& context) const; + protected: const char* m_name; const glu::ShaderType m_shaderType; @@ -208,6 +210,11 @@ OpaqueTypeIndexingCase::~OpaqueTypeIndexingCase (void) { } +void OpaqueTypeIndexingCase::checkSupport (Context& context) const +{ + checkSupportShader(context, m_shaderType); +} + class OpaqueTypeIndexingTestInstance : public TestInstance { public: diff --git a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp index 76d6de0..1ef5eec 100644 --- a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp +++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp @@ -3511,6 +3511,16 @@ bool executorSupported(glu::ShaderType shaderType) } } +void checkSupportShader(Context& context, const glu::ShaderType shaderType) +{ + if (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().tessellationIsolines) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Tessellation iso lines are not supported by this implementation"); + } +} + } // shaderexecutor } // vkt diff --git a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.hpp b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.hpp index 7174a25..c29d779 100644 --- a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.hpp +++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.hpp @@ -118,6 +118,7 @@ private: bool executorSupported (glu::ShaderType shaderType); void generateSources (glu::ShaderType shaderType, const ShaderSpec& shaderSpec, vk::SourceCollections& dst); ShaderExecutor* createExecutor (Context& context, glu::ShaderType shaderType, const ShaderSpec& shaderSpec, vk::VkDescriptorSetLayout extraResourcesLayout = (vk::VkDescriptorSetLayout)0); +void checkSupportShader (Context& context, const glu::ShaderType shaderType); } // shaderexecutor } // vkt diff --git a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderIntegerFunctionTests.cpp b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderIntegerFunctionTests.cpp index a7d2956..7cf2815 100644 --- a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderIntegerFunctionTests.cpp +++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderIntegerFunctionTests.cpp @@ -296,6 +296,8 @@ public: generateSources(m_shaderType, m_spec, programCollection); } + void checkSupport (Context& context) const; + virtual TestInstance* createInstance (Context& context) const = 0; protected: @@ -320,6 +322,11 @@ IntegerFunctionCase::~IntegerFunctionCase (void) { } +void IntegerFunctionCase::checkSupport (Context& context) const +{ + checkSupportShader(context, m_shaderType); +} + // IntegerFunctionTestInstance class IntegerFunctionTestInstance : public TestInstance diff --git a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderPackingFunctionTests.cpp b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderPackingFunctionTests.cpp index 5a1a5d8..e4e6f8f 100644 --- a/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderPackingFunctionTests.cpp +++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderPackingFunctionTests.cpp @@ -75,6 +75,7 @@ public: ShaderPackingFunctionCase (tcu::TestContext& testCtx, const char* name, const char* description, glu::ShaderType shaderType); ~ShaderPackingFunctionCase (void); + void checkSupport (Context& context) const; virtual void initPrograms (vk::SourceCollections& programCollection) const { generateSources(m_shaderType, m_spec, programCollection); @@ -99,6 +100,11 @@ ShaderPackingFunctionCase::~ShaderPackingFunctionCase (void) { } +void ShaderPackingFunctionCase::checkSupport (Context& context) const +{ + checkSupportShader(context, m_shaderType); +} + // ShaderPackingFunctionTestInstance class ShaderPackingFunctionTestInstance : public TestInstance diff --git a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderBuiltinVarTests.cpp b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderBuiltinVarTests.cpp index 46aa0da..541894a 100644 --- a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderBuiltinVarTests.cpp +++ b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderBuiltinVarTests.cpp @@ -207,6 +207,7 @@ public: virtual ~BuiltinGlFrontFacingCase (void); void initPrograms (SourceCollections& dst) const; + void checkSupport (Context& context) const; TestInstance* createInstance (Context& context) const; private: @@ -257,6 +258,16 @@ void BuiltinGlFrontFacingCase::initPrograms (SourceCollections& programCollectio } } +void BuiltinGlFrontFacingCase::checkSupport (Context& context) const +{ + if (m_topology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().triangleFans) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation"); + } +} + TestInstance* BuiltinGlFrontFacingCase::createInstance (Context& context) const { return new BuiltinGlFrontFacingCaseInstance(context, m_topology); diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsArithmeticTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsArithmeticTests.cpp index d9182f3..3841d9b 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsArithmeticTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsArithmeticTests.cpp @@ -289,6 +289,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotBroadcastTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotBroadcastTests.cpp index 3453168..f7dcdeb 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotBroadcastTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotBroadcastTests.cpp @@ -310,7 +310,7 @@ void supportedCheck (Context& context, CaseDefinition caseDef) *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); - + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotMasksTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotMasksTests.cpp index c622f7a..7828a4c 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotMasksTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotMasksTests.cpp @@ -441,6 +441,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotOtherTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotOtherTests.cpp index eb039a7..a93b61e 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotOtherTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotOtherTests.cpp @@ -507,6 +507,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotTests.cpp index b8260e7..0ffb2e5 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBallotTests.cpp @@ -955,6 +955,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBasicTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBasicTests.cpp index 9d0b8c9..d347479 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBasicTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBasicTests.cpp @@ -1895,6 +1895,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBuiltinMaskVarTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBuiltinMaskVarTests.cpp index 047ddea..4c1d2f6 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBuiltinMaskVarTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBuiltinMaskVarTests.cpp @@ -1394,6 +1394,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest(Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBuiltinVarTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBuiltinVarTests.cpp index afb033b..d9bd964 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBuiltinVarTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsBuiltinVarTests.cpp @@ -1624,6 +1624,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsClusteredTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsClusteredTests.cpp index 1e9ff24..2f6e5e3 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsClusteredTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsClusteredTests.cpp @@ -208,6 +208,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsPartitionedTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsPartitionedTests.cpp index 3f0e552..45e8bf1 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsPartitionedTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsPartitionedTests.cpp @@ -611,6 +611,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsQuadTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsQuadTests.cpp index 004104b..37175e9 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsQuadTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsQuadTests.cpp @@ -253,6 +253,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsShapeTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsShapeTests.cpp index 82a828c..3ef66dd 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsShapeTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsShapeTests.cpp @@ -505,6 +505,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsShuffleTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsShuffleTests.cpp index 457167a..c5e4bbc 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsShuffleTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsShuffleTests.cpp @@ -501,6 +501,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsSizeControlTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsSizeControlTests.cpp index 29b799d..6d37394 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsSizeControlTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsSizeControlTests.cpp @@ -660,6 +660,13 @@ void supportedCheckFeatures (Context& context, CaseDefinition caseDef) } } +void supportedCheckFeaturesShader (Context& context, CaseDefinition caseDef) +{ + supportedCheckFeatures(context, caseDef); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); +} + tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) { struct internalDataStruct internalData = @@ -1020,12 +1027,12 @@ tcu::TestCaseGroup* createSubgroupsSizeControlTests (tcu::TestContext& testCtx) const CaseDefinition caseDefCompute = {VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, VK_SHADER_STAGE_COMPUTE_BIT, DE_FALSE, REQUIRED_SUBGROUP_SIZE_NONE}; addFunctionCaseWithPrograms(computeGroup.get(), "allow_varying_subgroup_size", "", supportedCheckFeatures, initPrograms, test, caseDefCompute); const CaseDefinition caseDefAllGraphics = {VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, VK_SHADER_STAGE_ALL_GRAPHICS, DE_FALSE, REQUIRED_SUBGROUP_SIZE_NONE}; - addFunctionCaseWithPrograms(graphicsGroup.get(), "allow_varying_subgroup_size", "", supportedCheckFeatures, initPrograms, test, caseDefAllGraphics); + addFunctionCaseWithPrograms(graphicsGroup.get(), "allow_varying_subgroup_size", "", supportedCheckFeaturesShader, initPrograms, test, caseDefAllGraphics); for (int stageIndex = 0; stageIndex < DE_LENGTH_OF_ARRAY(stages); ++stageIndex) { const CaseDefinition caseDefStage = {VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, stages[stageIndex], DE_FALSE, REQUIRED_SUBGROUP_SIZE_NONE}; - addFunctionCaseWithPrograms(framebufferGroup.get(), getShaderStageName(caseDefStage.shaderStage) + "_allow_varying_subgroup_size", "", supportedCheckFeatures, initFrameBufferPrograms, noSSBOtest, caseDefStage); + addFunctionCaseWithPrograms(framebufferGroup.get(), getShaderStageName(caseDefStage.shaderStage) + "_allow_varying_subgroup_size", "", supportedCheckFeaturesShader, initFrameBufferPrograms, noSSBOtest, caseDefStage); } } @@ -1045,20 +1052,20 @@ tcu::TestCaseGroup* createSubgroupsSizeControlTests (tcu::TestContext& testCtx) // Tests to check setting a required subgroup size value. { const CaseDefinition caseDefAllGraphicsMax = {0u, VK_SHADER_STAGE_ALL_GRAPHICS, DE_FALSE, REQUIRED_SUBGROUP_SIZE_MAX}; - addFunctionCaseWithPrograms(graphicsGroup.get(), "required_subgroup_size_max", "", supportedCheckFeatures, initPrograms, testRequireSubgroupSize, caseDefAllGraphicsMax); + addFunctionCaseWithPrograms(graphicsGroup.get(), "required_subgroup_size_max", "", supportedCheckFeaturesShader, initPrograms, testRequireSubgroupSize, caseDefAllGraphicsMax); const CaseDefinition caseDefComputeMax = {0u, VK_SHADER_STAGE_COMPUTE_BIT, DE_FALSE, REQUIRED_SUBGROUP_SIZE_MAX}; addFunctionCaseWithPrograms(computeGroup.get(), "required_subgroup_size_max", "", supportedCheckFeatures, initPrograms, testRequireSubgroupSize, caseDefComputeMax); const CaseDefinition caseDefAllGraphicsMin = {0u, VK_SHADER_STAGE_ALL_GRAPHICS, DE_FALSE, REQUIRED_SUBGROUP_SIZE_MIN}; - addFunctionCaseWithPrograms(graphicsGroup.get(), "required_subgroup_size_min", "", supportedCheckFeatures, initPrograms, testRequireSubgroupSize, caseDefAllGraphicsMin); + addFunctionCaseWithPrograms(graphicsGroup.get(), "required_subgroup_size_min", "", supportedCheckFeaturesShader, initPrograms, testRequireSubgroupSize, caseDefAllGraphicsMin); const CaseDefinition caseDefComputeMin = {0u, VK_SHADER_STAGE_COMPUTE_BIT, DE_FALSE, REQUIRED_SUBGROUP_SIZE_MIN}; addFunctionCaseWithPrograms(computeGroup.get(), "required_subgroup_size_min", "", supportedCheckFeatures, initPrograms, testRequireSubgroupSize, caseDefComputeMin); for (int stageIndex = 0; stageIndex < DE_LENGTH_OF_ARRAY(stages); ++stageIndex) { const CaseDefinition caseDefStageMax = {0u, stages[stageIndex], DE_FALSE, REQUIRED_SUBGROUP_SIZE_MAX}; - addFunctionCaseWithPrograms(framebufferGroup.get(), getShaderStageName(caseDefStageMax.shaderStage) + "_required_subgroup_size_max", "", supportedCheckFeatures, initFrameBufferPrograms, noSSBOtestRequireSubgroupSize, caseDefStageMax); + addFunctionCaseWithPrograms(framebufferGroup.get(), getShaderStageName(caseDefStageMax.shaderStage) + "_required_subgroup_size_max", "", supportedCheckFeaturesShader, initFrameBufferPrograms, noSSBOtestRequireSubgroupSize, caseDefStageMax); const CaseDefinition caseDefStageMin = {0u, stages[stageIndex], DE_FALSE, REQUIRED_SUBGROUP_SIZE_MIN}; - addFunctionCaseWithPrograms(framebufferGroup.get(), getShaderStageName(caseDefStageMin.shaderStage) + "_required_subgroup_size_min", "", supportedCheckFeatures, initFrameBufferPrograms, noSSBOtestRequireSubgroupSize, caseDefStageMin); + addFunctionCaseWithPrograms(framebufferGroup.get(), getShaderStageName(caseDefStageMin.shaderStage) + "_required_subgroup_size_min", "", supportedCheckFeaturesShader, initFrameBufferPrograms, noSSBOtestRequireSubgroupSize, caseDefStageMin); } } diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsTestsUtils.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsTestsUtils.cpp index b03ecbe..c7264401 100644 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsTestsUtils.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsTestsUtils.cpp @@ -4094,3 +4094,13 @@ tcu::TestStatus vkt::subgroups::makeComputeTest( return makeComputeTestRequiredSubgroupSize(context, format, inputs, inputsCount, internalData, checkResult, pipelineShaderStageCreateFlags, numWorkgroups, requiredSubgroupSize != 0u, subgroupSize, localSizesToTest, localSizesToTestCount); } + +void vkt::subgroups::supportedCheckShader(Context& context, const vk::VkShaderStageFlags shaderStage) +{ + if ((VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) & shaderStage && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().tessellationIsolines) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Tessellation iso lines are not supported by this implementation"); + } +} diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsTestsUtils.hpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsTestsUtils.hpp index 167d42c..0d49ee0 100644 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsTestsUtils.hpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsTestsUtils.hpp @@ -281,6 +281,8 @@ tcu::TestStatus makeComputeTestRequiredSubgroupSize( deUint32 subgroupSize), const deUint32 pipelineShaderStageCreateFlags, const deUint32 numWorkgroups[3], const deBool isRequiredSubgroupSize, const deUint32 subgroupSize, const deUint32 localSizesToTest[][3], const deUint32 localSizesToTestCount); + +void supportedCheckShader(Context& context, const vk::VkShaderStageFlags shaderStage); } // subgroups } // vkt diff --git a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsVoteTests.cpp b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsVoteTests.cpp index 2228170..1a6e2a4 100755 --- a/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsVoteTests.cpp +++ b/external/vulkancts/modules/vulkan/subgroups/vktSubgroupsVoteTests.cpp @@ -679,6 +679,8 @@ void supportedCheck (Context& context, CaseDefinition caseDef) } *caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context); + + vkt::subgroups::supportedCheckShader(context, caseDef.shaderStage); } tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicEventTests.cpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicEventTests.cpp index c2e76f1..88dd71a 100644 --- a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicEventTests.cpp +++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicEventTests.cpp @@ -294,16 +294,22 @@ tcu::TestStatus secondaryCommandBufferCase (Context& context) return tcu::TestStatus::pass("Wait and set even on device using secondary command buffers tests pass"); } +void checkEventSupport (Context& context) +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && !context.getPortabilitySubsetFeatures().events) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Events are not supported by this implementation"); +} + } // anonymous tcu::TestCaseGroup* createBasicEventTests (tcu::TestContext& testCtx) { de::MovePtr basicTests(new tcu::TestCaseGroup(testCtx, "event", "Basic event tests")); - addFunctionCase(basicTests.get(), "host_set_reset", "Basic event tests set and reset on host", hostResetSetEventCase); - addFunctionCase(basicTests.get(), "device_set_reset", "Basic event tests set and reset on device", deviceResetSetEventCase); - addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer", "Wait and set event single submission on device", singleSubmissionCase); - addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer", "Wait and set event mutli submission on device", multiSubmissionCase); - addFunctionCase(basicTests.get(), "multi_secondary_command_buffer", "Event used on secondary command buffer ", secondaryCommandBufferCase); + addFunctionCase(basicTests.get(), "host_set_reset", "Basic event tests set and reset on host", checkEventSupport, hostResetSetEventCase); + addFunctionCase(basicTests.get(), "device_set_reset", "Basic event tests set and reset on device", checkEventSupport, deviceResetSetEventCase); + addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer", "Wait and set event single submission on device", checkEventSupport, singleSubmissionCase); + addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer", "Wait and set event mutli submission on device", checkEventSupport, multiSubmissionCase); + addFunctionCase(basicTests.get(), "multi_secondary_command_buffer", "Event used on secondary command buffer ", checkEventSupport, secondaryCommandBufferCase); return basicTests.release(); } diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp index f2df751..3fa8f76 100644 --- a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp +++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp @@ -582,6 +582,16 @@ public: return DE_NULL; } + void checkSupport (Context& context) const + { + if (SYNC_PRIMITIVE_EVENT == m_syncPrimitive && + context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().events) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Events are not supported by this implementation"); + } + } + private: const ResourceDescription m_resourceDesc; const de::SharedPtr m_writeOp; diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationCoordinatesTests.cpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationCoordinatesTests.cpp index ee71ae4..54eaf11 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationCoordinatesTests.cpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationCoordinatesTests.cpp @@ -371,6 +371,7 @@ public: const bool executionModeInEvaluationShader = true); void initPrograms (SourceCollections& programCollection) const; + void checkSupport (Context& context) const; TestInstance* createInstance (Context& context) const; private: @@ -390,6 +391,15 @@ TessCoordTest::TessCoordTest (tcu::TestContext& testCtx, { } +void TessCoordTest::checkSupport (Context& context) const +{ + if (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR* const features = getPortability(context)) + { + checkPointMode(*features); + checkPrimitive(*features, m_primitiveType); + } +} + void TessCoordTest::initPrograms (SourceCollections& programCollection) const { if (m_executionModeInEvaluationShader) diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationFractionalSpacingTests.cpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationFractionalSpacingTests.cpp index 62d30b2..72e2a5c 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationFractionalSpacingTests.cpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationFractionalSpacingTests.cpp @@ -649,6 +649,15 @@ tcu::TestStatus test (Context& context, TestParams testParams) return (success ? tcu::TestStatus::pass("OK") : tcu::TestStatus::fail("Failure")); } +void checkSupportTess(Context& context, const TestParams) +{ + if (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR* const features = getPortability(context)) + { + checkPointMode(*features); + checkIsolines(*features); + } +} + } // anonymous //! These tests correspond to dEQP-GLES31.functional.tessellation.fractional_spacing.* @@ -657,10 +666,10 @@ tcu::TestCaseGroup* createFractionalSpacingTests (tcu::TestContext& testCtx) { de::MovePtr group (new tcu::TestCaseGroup(testCtx, "fractional_spacing", "Test fractional spacing modes")); - addFunctionCaseWithPrograms(group.get(), "glsl_odd", "", initPrograms, test, TestParams(SHADER_LANGUAGE_GLSL, SPACINGMODE_FRACTIONAL_ODD)); - addFunctionCaseWithPrograms(group.get(), "glsl_even", "", initPrograms, test, TestParams(SHADER_LANGUAGE_GLSL, SPACINGMODE_FRACTIONAL_EVEN)); - addFunctionCaseWithPrograms(group.get(), "hlsl_odd", "", initPrograms, test, TestParams(SHADER_LANGUAGE_HLSL, SPACINGMODE_FRACTIONAL_ODD)); - addFunctionCaseWithPrograms(group.get(), "hlsl_even", "", initPrograms, test, TestParams(SHADER_LANGUAGE_HLSL, SPACINGMODE_FRACTIONAL_EVEN)); + addFunctionCaseWithPrograms(group.get(), "glsl_odd", "", checkSupportTess, initPrograms, test, TestParams(SHADER_LANGUAGE_GLSL, SPACINGMODE_FRACTIONAL_ODD)); + addFunctionCaseWithPrograms(group.get(), "glsl_even", "", checkSupportTess, initPrograms, test, TestParams(SHADER_LANGUAGE_GLSL, SPACINGMODE_FRACTIONAL_EVEN)); + addFunctionCaseWithPrograms(group.get(), "hlsl_odd", "", checkSupportTess, initPrograms, test, TestParams(SHADER_LANGUAGE_HLSL, SPACINGMODE_FRACTIONAL_ODD)); + addFunctionCaseWithPrograms(group.get(), "hlsl_even", "", checkSupportTess, initPrograms, test, TestParams(SHADER_LANGUAGE_HLSL, SPACINGMODE_FRACTIONAL_EVEN)); return group.release(); } diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationGeometryPassthroughTests.cpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationGeometryPassthroughTests.cpp index b005e6d..2c3ca8c 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationGeometryPassthroughTests.cpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationGeometryPassthroughTests.cpp @@ -127,6 +127,7 @@ class IdentityGeometryShaderTestCase : public TestCase { public: void initPrograms (vk::SourceCollections& programCollection) const; + void checkSupport (Context& context) const; TestInstance* createInstance (Context& context) const; IdentityGeometryShaderTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TessPrimitiveType primitiveType) @@ -139,6 +140,11 @@ private: const TessPrimitiveType m_primitiveType; }; +void IdentityGeometryShaderTestCase::checkSupport (Context& context) const +{ + checkSupportPrimitive(context, m_primitiveType); +} + void IdentityGeometryShaderTestCase::initPrograms (vk::SourceCollections& programCollection) const { addVertexAndFragmentShaders(programCollection); @@ -216,6 +222,7 @@ class IdentityTessellationShaderTestCase : public TestCase { public: void initPrograms (vk::SourceCollections& programCollection) const; + void checkSupport (Context& context) const; TestInstance* createInstance (Context& context) const; IdentityTessellationShaderTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TessPrimitiveType primitiveType) @@ -228,6 +235,11 @@ private: const TessPrimitiveType m_primitiveType; }; +void IdentityTessellationShaderTestCase::checkSupport (Context& context) const +{ + checkSupportPrimitive(context, m_primitiveType); +} + //! Geometry shader used in passthrough tessellation shader case. std::string generateGeometryShader (const TessPrimitiveType primitiveType, const std::string& colorSourceName) { diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationGeometryPointSizeTests.cpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationGeometryPointSizeTests.cpp index 5df3ed1..3dc453e 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationGeometryPointSizeTests.cpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationGeometryPointSizeTests.cpp @@ -435,6 +435,13 @@ std::string getTestCaseDescription (const Flags flags) return buf.str(); } +void checkSupportTess (Context& context, const Flags flags) +{ + if (isTessellationStage(flags)) + if (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR* const features = getPortability(context)) + checkPointMode(*features); +} + } // anonymous //! Ported from dEQP-GLES31.functional.tessellation_geometry_interaction.point_size.* @@ -459,7 +466,7 @@ tcu::TestCaseGroup* createGeometryPointSizeTests (tcu::TestContext& testCtx) const std::string name = getTestCaseName (caseFlags[ndx]); const std::string desc = getTestCaseDescription(caseFlags[ndx]); - addFunctionCaseWithPrograms(group.get(), name, desc, initPrograms, test, caseFlags[ndx]); + addFunctionCaseWithPrograms(group.get(), name, desc, checkSupportTess, initPrograms, test, caseFlags[ndx]); } return group.release(); diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationInvarianceTests.cpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationInvarianceTests.cpp index 01cb0ff..3be1785 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationInvarianceTests.cpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationInvarianceTests.cpp @@ -1027,6 +1027,12 @@ public: return new OuterEdgeDivisionTestInstance(context, m_caseDef); }; + void checkSupport (Context& context) const + { + if (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR* const features = getPortability(context)) + checkPointMode(*features); + } + private: const CaseDefinition m_caseDef; }; @@ -1051,6 +1057,11 @@ public: return new OuterEdgeIndexIndependenceTestInstance(context, m_caseDef); }; + void checkSupport (Context& context) const + { + checkSupportCase(context, m_caseDef); + } + private: const CaseDefinition m_caseDef; }; @@ -1075,6 +1086,11 @@ public: return new SymmetricOuterEdgeTestInstance(context, m_caseDef); }; + void checkSupport (Context& context) const + { + checkSupportCase(context, m_caseDef); + } + private: const CaseDefinition m_caseDef; }; @@ -1266,6 +1282,7 @@ public: virtual ~InvarianceTestCase (void) {} void initPrograms (SourceCollections& programCollection) const; + void checkSupport (Context& context) const; TestInstance* createInstance (Context& context) const; private: @@ -1277,6 +1294,11 @@ void InvarianceTestCase::initPrograms (SourceCollections& programCollection) con addDefaultPrograms(programCollection, m_caseDef.primitiveType, m_caseDef.spacingMode, m_caseDef.windingUsage, getPointModeUsage(m_caseDef.usePointMode)); } +void InvarianceTestCase::checkSupport (Context& context) const +{ + checkSupportCase(context, m_caseDef); +} + class InvarianceTestInstance : public TestInstance { public: @@ -2137,13 +2159,13 @@ tcu::TestStatus test (Context& context, const CaseDefinition caseDef) tcu::TestCase* makeTessCoordRangeTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TessPrimitiveType primitiveType, const SpacingMode spacingMode, const Winding winding, const bool usePointMode) { const CaseDefinition caseDef = { CASETYPE_TESS_COORD_RANGE, primitiveType, spacingMode, winding, usePointMode }; - return createFunctionCaseWithPrograms(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, description, initPrograms, test, caseDef); + return createFunctionCaseWithPrograms(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, description, checkSupportCase, initPrograms, test, caseDef); } tcu::TestCase* makeOneMinusTessCoordTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TessPrimitiveType primitiveType, const SpacingMode spacingMode, const Winding winding, const bool usePointMode) { const CaseDefinition caseDef = { CASETYPE_ONE_MINUS_TESS_COORD, primitiveType, spacingMode, winding, usePointMode }; - return createFunctionCaseWithPrograms(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, description, initPrograms, test, caseDef); + return createFunctionCaseWithPrograms(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, description, checkSupportCase, initPrograms, test, caseDef); } } // TessCoordComponent ns diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationMiscDrawTests.cpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationMiscDrawTests.cpp index 458d6a7..610628a 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationMiscDrawTests.cpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationMiscDrawTests.cpp @@ -585,7 +585,7 @@ tcu::TestCaseGroup* createMiscDrawTests (tcu::TestContext& testCtx) const SpacingMode spacingMode = static_cast(spacingModeNdx); const std::string caseName = std::string() + "isolines_" + getSpacingModeShaderName(spacingMode); - addFunctionCaseWithPrograms(group.get(), caseName, "Basic isolines render test", + addFunctionCaseWithPrograms(group.get(), caseName, "Basic isolines render test", checkSupportCase, initProgramsIsolinesCase, runTest, makeCaseDefinition(TESSPRIMITIVETYPE_ISOLINES, spacingMode, getReferenceImagePathPrefix(caseName))); } diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationPrimitiveDiscardTests.cpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationPrimitiveDiscardTests.cpp index 1927ea9..4b7fd86 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationPrimitiveDiscardTests.cpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationPrimitiveDiscardTests.cpp @@ -626,7 +626,7 @@ tcu::TestCaseGroup* createPrimitiveDiscardTests (tcu::TestContext& testCtx) + (caseDef.usePointMode ? "_point_mode" : "") + (caseDef.useLessThanOneInnerLevels ? "" : "_valid_levels"); - addFunctionCaseWithPrograms(group.get(), caseName, "", initPrograms, test, caseDef); + addFunctionCaseWithPrograms(group.get(), caseName, "", checkSupportCase, initPrograms, test, caseDef); } return group.release(); diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationUserDefinedIO.cpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationUserDefinedIO.cpp index 106ee04..b1597b3 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationUserDefinedIO.cpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationUserDefinedIO.cpp @@ -436,6 +436,7 @@ class UserDefinedIOTest : public TestCase public: UserDefinedIOTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const CaseDefinition caseDef); void initPrograms (vk::SourceCollections& programCollection) const; + void checkSupport (Context& context) const; TestInstance* createInstance (Context& context) const; private: @@ -449,6 +450,11 @@ private: std::string m_tesStatements; }; +void UserDefinedIOTest::checkSupport (Context& context) const +{ + checkSupportCase(context, m_caseDef); +} + UserDefinedIOTest::UserDefinedIOTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const CaseDefinition caseDef) : TestCase (testCtx, name, description) , m_caseDef (caseDef) diff --git a/external/vulkancts/modules/vulkan/tessellation/vktTessellationUtil.hpp b/external/vulkancts/modules/vulkan/tessellation/vktTessellationUtil.hpp index 9b7ba42..09c74ea 100644 --- a/external/vulkancts/modules/vulkan/tessellation/vktTessellationUtil.hpp +++ b/external/vulkancts/modules/vulkan/tessellation/vktTessellationUtil.hpp @@ -31,6 +31,7 @@ #include "vkRefUtil.hpp" #include "vkQueryUtil.hpp" #include "vkObjUtil.hpp" +#include "vktTestCase.hpp" #include "tcuVector.hpp" #include "tcuMaybe.hpp" @@ -372,6 +373,37 @@ static inline const char* getGeometryShaderOutputPrimitiveTypeShaderName (const } } +static inline const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR* getPortability (const Context& context) +{ + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset")) + return &context.getPortabilitySubsetFeatures(); + return DE_NULL; +} + +static inline void checkIsolines (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR& features) +{ + if (!features.tessellationIsolines) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Tessellation iso lines are not supported by this implementation"); +} + +static inline void checkPrimitive (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR& features, const TessPrimitiveType primitive) +{ + if (primitive == TESSPRIMITIVETYPE_ISOLINES) + checkIsolines(features); +} + +static inline void checkSupportPrimitive (Context& context, const TessPrimitiveType primitive) +{ + if (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR* const features = getPortability(context)) + checkPrimitive(*features, primitive); +} + +static inline void checkPointMode (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR& features) +{ + if (!features.tessellationPointMode) + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Tessellation point mode is not supported by this implementation"); +} + template inline std::size_t sizeInBytes (const std::vector& vec) { @@ -448,6 +480,34 @@ std::vector readInterleavedData (const int count, const void* memory, const i return results; } +template +struct PointMode +{ + static void check(const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR&, const CaseDef) + { + } +}; + +template +struct PointMode +{ + static void check(const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR& features, const CaseDef caseDef) + { + if (caseDef.usePointMode) + checkPointMode(features); + } +}; + +template +void checkSupportCase (Context& context, const CaseDef caseDef) +{ + if (const vk::VkPhysicalDevicePortabilitySubsetFeaturesKHR* const features = getPortability(context)) + { + PointMode::check(*features, caseDef); + checkPrimitive(*features, caseDef.primitiveType); + } +} + } // tessellation } // vkt diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureCompressedFormatTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureCompressedFormatTests.cpp index 9ea2c51..65a2b14 100644 --- a/external/vulkancts/modules/vulkan/texture/vktTextureCompressedFormatTests.cpp +++ b/external/vulkancts/modules/vulkan/texture/vktTextureCompressedFormatTests.cpp @@ -392,6 +392,8 @@ tcu::TestStatus Compressed3DTestInstance::iterate (void) return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed"); } +} // anonymous + void populateTextureCompressedFormatTests (tcu::TestCaseGroup* compressedTextureTests) { tcu::TestContext& testCtx = compressedTextureTests->getTestContext(); @@ -443,8 +445,6 @@ void populate3DTextureCompressedFormatTests (tcu::TestCaseGroup* compressedTextu } } -} // anonymous - tcu::TestCaseGroup* createTextureCompressedFormatTests (tcu::TestContext& testCtx) { return createTestGroup(testCtx, "compressed", "Texture compressed format tests.", populateTextureCompressedFormatTests); diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringExplicitLodTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringExplicitLodTests.cpp index 979103e..0d4e6ab 100644 --- a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringExplicitLodTests.cpp +++ b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringExplicitLodTests.cpp @@ -28,6 +28,7 @@ #include "vktSampleVerifier.hpp" #include "vktShaderExecutor.hpp" #include "vktTestCaseUtil.hpp" +#include "vktTextureTestUtil.hpp" #include "vkDeviceUtil.hpp" #include "vkImageUtil.hpp" @@ -952,6 +953,11 @@ public: void initSpec (void); + void checkSupport (Context& context) const + { + util::checkTextureSupport(context, m_testCaseData.imParams.format); + } + virtual void initPrograms (vk::SourceCollections& programCollection) const { generateSources(m_testCaseData.shaderType, m_shaderSpec, programCollection); diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp index c7bac52..148a5fc 100644 --- a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp +++ b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp @@ -1045,6 +1045,9 @@ bool verifierCanBeUsed(const VkFormat format, const Sampler::FilterMode minFilte (tcu::TexVerifierUtil::isLinearFilter(minFilter) || tcu::TexVerifierUtil::isLinearFilter(magFilter) || tcu::TexVerifierUtil::isCubicFilter(minFilter) || tcu::TexVerifierUtil::isCubicFilter(magFilter))); } + +} // anonymous + void populateTextureFilteringTests (tcu::TestCaseGroup* textureFilteringTests) { tcu::TestContext& testCtx = textureFilteringTests->getTestContext(); @@ -1781,8 +1784,6 @@ void populateTextureFilteringTests (tcu::TestCaseGroup* textureFilteringTests) } } -} // anonymous - tcu::TestCaseGroup* createTextureFilteringTests (tcu::TestContext& testCtx) { return createTestGroup(testCtx, "filtering", "Texture filtering tests.", populateTextureFilteringTests); diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureMipmapTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureMipmapTests.cpp index bf637c8..b21c0f8 100644 --- a/external/vulkancts/modules/vulkan/texture/vktTextureMipmapTests.cpp +++ b/external/vulkancts/modules/vulkan/texture/vktTextureMipmapTests.cpp @@ -1698,6 +1698,8 @@ protected: } }; +} // anonymous + void populateTextureMipmappingTests (tcu::TestCaseGroup* textureMipmappingTests) { tcu::TestContext& testCtx = textureMipmappingTests->getTestContext(); @@ -2164,8 +2166,6 @@ void populateTextureMipmappingTests (tcu::TestCaseGroup* textureMipmappingTests) } } -} // anonymous - tcu::TestCaseGroup* createTextureMipmappingTests (tcu::TestContext& testCtx) { return createTestGroup(testCtx, "mipmap", "Texture mipmapping tests.", populateTextureMipmappingTests); diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureShadowTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureShadowTests.cpp index 764167c..3066c43 100644 --- a/external/vulkancts/modules/vulkan/texture/vktTextureShadowTests.cpp +++ b/external/vulkancts/modules/vulkan/texture/vktTextureShadowTests.cpp @@ -813,6 +813,8 @@ tcu::TestStatus Texture2DArrayShadowTestInstance::iterate (void) return m_caseNdx < (int)m_cases.size() ? tcu::TestStatus::incomplete() : tcu::TestStatus::pass("Pass"); } +} // anonymous + void populateTextureShadowTests (tcu::TestCaseGroup* textureShadowTests) { tcu::TestContext& testCtx = textureShadowTests->getTestContext(); @@ -995,8 +997,6 @@ void populateTextureShadowTests (tcu::TestCaseGroup* textureShadowTests) } } -} // anonymous - tcu::TestCaseGroup* createTextureShadowTests (tcu::TestContext& testCtx) { return createTestGroup(testCtx, "shadow", "Texture shadow tests.", populateTextureShadowTests); diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureSwizzleTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureSwizzleTests.cpp index 729674f..c01a2bb 100644 --- a/external/vulkancts/modules/vulkan/texture/vktTextureSwizzleTests.cpp +++ b/external/vulkancts/modules/vulkan/texture/vktTextureSwizzleTests.cpp @@ -283,6 +283,8 @@ tcu::TestStatus Swizzle2DTestInstance::iterate (void) return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed"); } +} // anonymous + void populateTextureSwizzleTests (tcu::TestCaseGroup* textureSwizzleTests) { tcu::TestContext& testCtx = textureSwizzleTests->getTestContext(); @@ -523,8 +525,6 @@ void populateTextureSwizzleTests (tcu::TestCaseGroup* textureSwizzleTests) textureSwizzleTests->addChild(groupTexCoord.release()); } -} // anonymous - tcu::TestCaseGroup* createTextureSwizzleTests (tcu::TestContext& testCtx) { return createTestGroup(testCtx, "swizzle", "Texture swizzle tests.", populateTextureSwizzleTests); diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp b/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp index 7acf075..dae4252 100644 --- a/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp +++ b/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp @@ -171,6 +171,9 @@ private: vk::VkComponentMapping m_componentMapping; }; +void checkTextureSupport (Context& context, const vk::VkFormat imageFormat, const vk::VkComponentMapping& imageComponents, + const vk::VkFormat viewFormat, const vk::VkComponentMapping& viewComponents); + typedef de::SharedPtr TextureBindingSp; class TextureRenderer @@ -321,6 +324,7 @@ public: { initializePrograms(programCollection, m_testsParameters.texCoordPrecision, m_testsParameters.programs); } + virtual void checkSupport (Context& context) const { checkTextureSupport(context, m_testsParameters);