1 /*-------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2015 Google Inc.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Vulkan Test Package
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktTestPackage.hpp"
25
26 #include "qpDebugOut.h"
27 #include "qpInfo.h"
28
29 #include "tcuPlatform.hpp"
30 #include "tcuTestCase.hpp"
31 #include "tcuTestLog.hpp"
32 #include "tcuCommandLine.hpp"
33 #include "tcuWaiverUtil.hpp"
34
35 #include "vkPlatform.hpp"
36 #include "vkPrograms.hpp"
37 #include "vkBinaryRegistry.hpp"
38 #include "vkShaderToSpirV.hpp"
39 #include "vkDebugReportUtil.hpp"
40 #include "vkQueryUtil.hpp"
41 #include "vkApiVersion.hpp"
42 #include "vkRenderDocUtil.hpp"
43 #include "vkResourceInterface.hpp"
44
45 #include "deUniquePtr.hpp"
46 #include "deSharedPtr.hpp"
47 #ifdef CTS_USES_VULKANSC
48 #include "deProcess.h"
49 #include "vksClient.hpp"
50 #include "vksIPC.hpp"
51 #endif // CTS_USES_VULKANSC
52
53 #include "vktTestGroupUtil.hpp"
54 #include "vktApiTests.hpp"
55 #include "vktPipelineTests.hpp"
56 #include "vktBindingModelTests.hpp"
57 #include "vktSpvAsmTests.hpp"
58 #include "vktShaderLibrary.hpp"
59 #include "vktRenderPassTests.hpp"
60 #include "vktMemoryTests.hpp"
61 #include "vktShaderRenderBuiltinVarTests.hpp"
62 #include "vktShaderRenderDerivateTests.hpp"
63 #include "vktShaderRenderDiscardTests.hpp"
64 #include "vktShaderRenderIndexingTests.hpp"
65 #include "vktShaderRenderInvarianceTests.hpp"
66 #include "vktShaderRenderLimitTests.hpp"
67 #include "vktShaderRenderLoopTests.hpp"
68 #include "vktShaderRenderMatrixTests.hpp"
69 #include "vktShaderRenderOperatorTests.hpp"
70 #include "vktShaderRenderReturnTests.hpp"
71 #include "vktShaderRenderStructTests.hpp"
72 #include "vktShaderRenderSwitchTests.hpp"
73 #include "vktShaderRenderTextureFunctionTests.hpp"
74 #include "vktShaderRenderTextureGatherTests.hpp"
75 #include "vktShaderBuiltinTests.hpp"
76 #include "vktOpaqueTypeIndexingTests.hpp"
77 #include "vktAtomicOperationTests.hpp"
78 #include "vktUniformBlockTests.hpp"
79 #include "vktDynamicStateTests.hpp"
80 #include "vktSSBOLayoutTests.hpp"
81 #include "vktQueryPoolTests.hpp"
82 #include "vktDrawTests.hpp"
83 #include "vktComputeTests.hpp"
84 #include "vktConditionalTests.hpp"
85 #include "vktImageTests.hpp"
86 #include "vktInfoTests.hpp"
87 #include "vktWsiTests.hpp"
88 #include "vktSynchronizationTests.hpp"
89 #include "vktSparseResourcesTests.hpp"
90 #include "vktTessellationTests.hpp"
91 #include "vktRasterizationTests.hpp"
92 #include "vktClippingTests.hpp"
93 #include "vktFragmentOperationsTests.hpp"
94 #include "vktTextureTests.hpp"
95 #include "vktGeometryTests.hpp"
96 #include "vktRobustnessTests.hpp"
97 #include "vktMultiViewTests.hpp"
98 #include "vktSubgroupsTests.hpp"
99 #include "vktYCbCrTests.hpp"
100 #include "vktProtectedMemTests.hpp"
101 #include "vktDeviceGroupTests.hpp"
102 #include "vktMemoryModelTests.hpp"
103 #include "vktAmberGraphicsFuzzTests.hpp"
104 #include "vktAmberGlslTests.hpp"
105 #include "vktAmberDepthTests.hpp"
106 #include "vktImagelessFramebufferTests.hpp"
107 #include "vktTransformFeedbackTests.hpp"
108 #include "vktDescriptorIndexingTests.hpp"
109 #include "vktImagelessFramebufferTests.hpp"
110 #include "vktFragmentShaderInterlockTests.hpp"
111 #include "vktShaderClockTests.hpp"
112 #include "vktModifiersTests.hpp"
113 #include "vktRayTracingTests.hpp"
114 #include "vktRayQueryTests.hpp"
115 #include "vktPostmortemTests.hpp"
116 #include "vktFragmentShadingRateTests.hpp"
117 #include "vktReconvergenceTests.hpp"
118 #include "vktMeshShaderTests.hpp"
119 #include "vktFragmentShadingBarycentricTests.hpp"
120 #include "vktVideoTests.hpp"
121 #ifdef CTS_USES_VULKANSC
122 #include "vktSafetyCriticalTests.hpp"
123 #endif // CTS_USES_VULKANSC
124
125 #include <vector>
126 #include <sstream>
127 #include <fstream>
128 #include <thread>
129
130 namespace vkt
131 {
132
133 using std::vector;
134 using de::UniquePtr;
135 using de::SharedPtr;
136 using de::MovePtr;
137 using tcu::TestLog;
138
139 // TestCaseExecutor
140
141 #ifdef CTS_USES_VULKANSC
142 struct DetailedSubprocessTestCount
143 {
144 std::string testPattern;
145 int testCount;
146 };
147 #endif // CTS_USES_VULKANSC
148
149 class TestCaseExecutor : public tcu::TestCaseExecutor
150 {
151 public:
152 TestCaseExecutor (tcu::TestContext& testCtx);
153 ~TestCaseExecutor (void);
154
155 void init (tcu::TestCase* testCase, const std::string& path) override;
156 void deinit (tcu::TestCase* testCase) override;
157
158 tcu::TestNode::IterateResult iterate (tcu::TestCase* testCase) override;
159
160 void deinitTestPackage (tcu::TestContext& testCtx) override;
161 bool usesLocalStatus () override;
162 void updateGlobalStatus (tcu::TestRunStatus& status) override;
163 void reportDurations (tcu::TestContext& testCtx, const std::string& packageName, const deInt64& duration, const std::map<std::string, deUint64>& groupsDurationTime) override;
164 int getCurrentSubprocessCount (const std::string& casePath, int defaultSubprocessCount);
165
166 private:
167 void logUnusedShaders (tcu::TestCase* testCase);
168
169 void runTestsInSubprocess (tcu::TestContext& testCtx);
170
171 bool spirvVersionSupported (vk::SpirvVersion);
172
173 vk::BinaryCollection m_progCollection;
174 vk::BinaryRegistryReader m_prebuiltBinRegistry;
175
176 const UniquePtr<vk::Library> m_library;
177 MovePtr<Context> m_context;
178
179 const UniquePtr<vk::RenderDocUtil> m_renderDoc;
180 SharedPtr<vk::ResourceInterface> m_resourceInterface;
181 vk::VkPhysicalDeviceProperties m_deviceProperties;
182 tcu::WaiverUtil m_waiverMechanism;
183
184 TestInstance* m_instance; //!< Current test case instance
185 std::vector<std::string> m_testsForSubprocess;
186 tcu::TestRunStatus m_status;
187
188 #ifdef CTS_USES_VULKANSC
189 int m_subprocessCount;
190
191 std::unique_ptr<vksc_server::ipc::Parent> m_parentIPC;
192 std::vector<DetailedSubprocessTestCount> m_detailedSubprocessTestCount;
193 #endif // CTS_USES_VULKANSC
194 };
195
196 #ifdef CTS_USES_VULKANSC
supressedWrite(int,const char *)197 static deBool supressedWrite (int, const char*) { return false; }
supressedWriteFtm(int,const char *,va_list)198 static deBool supressedWriteFtm (int, const char*, va_list) { return false; }
openWrite(int type,const char * message)199 static deBool openWrite (int type, const char* message) { DE_UNREF(type); DE_UNREF(message); return true; }
openWriteFtm(int type,const char * format,va_list args)200 static deBool openWriteFtm (int type, const char* format, va_list args) { DE_UNREF(type); DE_UNREF(format); DE_UNREF(args); return true; }
suppressStandardOutput()201 static void suppressStandardOutput () { qpRedirectOut(supressedWrite, supressedWriteFtm); }
restoreStandardOutput()202 static void restoreStandardOutput () { qpRedirectOut(openWrite, openWriteFtm); }
203 #endif // CTS_USES_VULKANSC
204
createLibrary(tcu::TestContext & testCtx)205 static MovePtr<vk::Library> createLibrary (tcu::TestContext& testCtx)
206 {
207 #if (DE_OS == DE_OS_WIN32) || (DE_OS == DE_OS_UNIX)
208 return MovePtr<vk::Library>(testCtx.getPlatform().getVulkanPlatform().createLibrary(vk::Platform::LIBRARY_TYPE_VULKAN, testCtx.getCommandLine().getVkLibraryPath()));
209 #else
210 return MovePtr<vk::Library>(testCtx.getPlatform().getVulkanPlatform().createLibrary(testCtx.getCommandLine().getVkLibraryPath()));
211 #endif
212 }
213
getPhysicalDeviceProperties(vkt::Context & context)214 static vk::VkPhysicalDeviceProperties getPhysicalDeviceProperties(vkt::Context& context)
215 {
216 const vk::InstanceInterface& vki = context.getInstanceInterface();
217 const vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
218
219 vk::VkPhysicalDeviceProperties properties;
220 vki.getPhysicalDeviceProperties(physicalDevice, &properties);
221 return properties;
222 }
223
trim(const std::string & original)224 std::string trim (const std::string& original)
225 {
226 static const std::string whiteSigns = " \t";
227 const auto beg = original.find_first_not_of(whiteSigns);
228 if (beg == std::string::npos)
229 return std::string();
230 const auto end = original.find_last_not_of(whiteSigns);
231 return original.substr(beg, end - beg + 1);
232 }
233
TestCaseExecutor(tcu::TestContext & testCtx)234 TestCaseExecutor::TestCaseExecutor (tcu::TestContext& testCtx)
235 : m_prebuiltBinRegistry (testCtx.getArchive(), "vulkan/prebuilt")
236 , m_library (createLibrary(testCtx))
237 , m_renderDoc (testCtx.getCommandLine().isRenderDocEnabled()
238 ? MovePtr<vk::RenderDocUtil>(new vk::RenderDocUtil())
239 : MovePtr<vk::RenderDocUtil>(DE_NULL))
240 #if defined CTS_USES_VULKANSC
241 , m_resourceInterface (new vk::ResourceInterfaceVKSC(testCtx))
242 #else
243 , m_resourceInterface (new vk::ResourceInterfaceStandard(testCtx))
244 #endif // CTS_USES_VULKANSC
245 , m_instance (DE_NULL)
246 #if defined CTS_USES_VULKANSC
247 , m_subprocessCount (0)
248 #endif // CTS_USES_VULKANSC
249 {
250 #ifdef CTS_USES_VULKANSC
251 std::vector<int> caseFraction = testCtx.getCommandLine().getCaseFraction();
252 std::string jsonFileName;
253 int portOffset;
254 if (caseFraction.empty())
255 {
256 jsonFileName = "pipeline_data.txt";
257 portOffset = 0;
258 }
259 else
260 {
261 jsonFileName = "pipeline_data_" + std::to_string(caseFraction[0]) + ".txt";
262 portOffset = caseFraction[0];
263 }
264
265 if (testCtx.getCommandLine().isSubProcess())
266 {
267 std::vector<deUint8> input = vksc_server::ipc::Child{portOffset}.GetFile(jsonFileName);
268 m_resourceInterface->importData(input);
269 }
270 else
271 {
272 m_parentIPC.reset( new vksc_server::ipc::Parent{portOffset} );
273 }
274
275 // Load information about test tree branches that use subprocess test count other than default
276 // Expected file format:
277 if (!testCtx.getCommandLine().isSubProcess() && !std::string(testCtx.getCommandLine().getSubprocessConfigFile()).empty())
278 {
279 std::ifstream iFile(testCtx.getCommandLine().getSubprocessConfigFile(), std::ios::in);
280 if (!iFile)
281 TCU_THROW(InternalError, (std::string("Missing config file defining number of tests: ") + testCtx.getCommandLine().getSubprocessConfigFile()).c_str());
282 std::string line;
283 while (std::getline(iFile, line))
284 {
285 if (line.empty())
286 continue;
287 std::size_t pos = line.find_first_of(',');
288 if (pos == std::string::npos)
289 continue;
290 std::string testPattern, testNumber;
291 std::copy(line.begin(), line.begin() + pos, std::back_inserter(testPattern));
292 testPattern = trim(testPattern);
293 std::copy(line.begin() + pos + 1, line.end(), std::back_inserter(testNumber));
294 testNumber = trim(testNumber);
295 if (testPattern.empty() || testNumber.empty())
296 continue;
297 std::istringstream is(testNumber);
298 int testCount;
299 if ((is >> testCount).fail())
300 continue;
301 m_detailedSubprocessTestCount.push_back(DetailedSubprocessTestCount{ testPattern, testCount });
302 }
303 // sort test patterns
304 std::sort(m_detailedSubprocessTestCount.begin(), m_detailedSubprocessTestCount.end(), [](const DetailedSubprocessTestCount& lhs, const DetailedSubprocessTestCount& rhs)
305 {
306 return lhs.testCount < rhs.testCount;
307 } );
308 }
309
310 // If we are provided with remote location
311 if (!std::string(testCtx.getCommandLine().getServerAddress()).empty())
312 {
313 // Open connection with the server dedicated for standard output
314 vksc_server::OpenRemoteStandardOutput(testCtx.getCommandLine().getServerAddress());
315 restoreStandardOutput();
316 }
317 #endif // CTS_USES_VULKANSC
318
319 m_context = MovePtr<Context>(new Context(testCtx, m_library->getPlatformInterface(), m_progCollection, m_resourceInterface));
320 m_deviceProperties = getPhysicalDeviceProperties(*m_context);
321
322 tcu::SessionInfo sessionInfo(m_deviceProperties.vendorID,
323 m_deviceProperties.deviceID,
324 testCtx.getCommandLine().getInitialCmdLine());
325 m_waiverMechanism.setup(testCtx.getCommandLine().getWaiverFileName(),
326 "dEQP-VK",
327 m_deviceProperties.vendorID,
328 m_deviceProperties.deviceID,
329 sessionInfo);
330
331 #ifdef CTS_USES_VULKANSC
332 if (!std::string(testCtx.getCommandLine().getServerAddress()).empty())
333 {
334 vksc_server::AppendRequest request;
335 request.fileName = testCtx.getCommandLine().getLogFileName();
336
337 std::ostringstream str;
338 str << "#sessionInfo releaseName " << qpGetReleaseName() << std::endl;
339 str << "#sessionInfo releaseId 0x" << std::hex << std::setw(8) << std::setfill('0') << qpGetReleaseId() << std::endl;
340 str << "#sessionInfo targetName \"" << qpGetTargetName() << "\"" << std::endl;
341 str << sessionInfo.get() << std::endl;
342 str << "#beginSession" << std::endl;
343
344 std::string output = str.str();
345 request.data.assign(output.begin(), output.end());
346 request.clear = true;
347 vksc_server::StandardOutputServerSingleton()->SendRequest(request);
348 }
349 else
350 #endif // CTS_USES_VULKANSC
351 {
352 testCtx.getLog().writeSessionInfo(sessionInfo.get());
353 }
354
355 #ifdef CTS_USES_VULKANSC
356 m_resourceInterface->initApiVersion(m_context->getUsedApiVersion());
357
358 // Real Vulkan SC tests are performed in subprocess.
359 // Tests run in main process are only used to collect data required by Vulkan SC.
360 // That's why we turn off any output in main process and copy output from subprocess when subprocess tests are performed
361 if (!testCtx.getCommandLine().isSubProcess())
362 {
363 suppressStandardOutput();
364 m_context->getTestContext().getLog().supressLogging(true);
365 }
366 #endif // CTS_USES_VULKANSC
367 }
368
~TestCaseExecutor(void)369 TestCaseExecutor::~TestCaseExecutor (void)
370 {
371 delete m_instance;
372 }
373
init(tcu::TestCase * testCase,const std::string & casePath)374 void TestCaseExecutor::init (tcu::TestCase* testCase, const std::string& casePath)
375 {
376 if (m_waiverMechanism.isOnWaiverList(casePath))
377 throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
378
379 TestCase* vktCase = dynamic_cast<TestCase*>(testCase);
380 tcu::TestLog& log = m_context->getTestContext().getLog();
381 const deUint32 usedVulkanVersion = m_context->getUsedApiVersion();
382 const vk::SpirvVersion baselineSpirvVersion = vk::getBaselineSpirvVersion(usedVulkanVersion);
383 vk::ShaderBuildOptions defaultGlslBuildOptions (usedVulkanVersion, baselineSpirvVersion, 0u);
384 vk::ShaderBuildOptions defaultHlslBuildOptions (usedVulkanVersion, baselineSpirvVersion, 0u);
385 vk::SpirVAsmBuildOptions defaultSpirvAsmBuildOptions (usedVulkanVersion, baselineSpirvVersion);
386 vk::SourceCollections sourceProgs (usedVulkanVersion, defaultGlslBuildOptions, defaultHlslBuildOptions, defaultSpirvAsmBuildOptions);
387 const tcu::CommandLine& commandLine = m_context->getTestContext().getCommandLine();
388 const bool doShaderLog = commandLine.isLogDecompiledSpirvEnabled() && log.isShaderLoggingEnabled();
389
390 if (!vktCase)
391 TCU_THROW(InternalError, "Test node not an instance of vkt::TestCase");
392
393 {
394 #ifdef CTS_USES_VULKANSC
395 int currentSubprocessCount = getCurrentSubprocessCount(casePath, m_context->getTestContext().getCommandLine().getSubprocessTestCount());
396 if (m_subprocessCount && currentSubprocessCount != m_subprocessCount)
397 {
398 runTestsInSubprocess(m_context->getTestContext());
399
400 // Clean up data after performing tests in subprocess and prepare system for another batch of tests
401 m_testsForSubprocess.clear();
402 const vk::DeviceInterface& vkd = m_context->getDeviceInterface();
403 const vk::DeviceDriverSC* dds = dynamic_cast<const vk::DeviceDriverSC*>(&vkd);
404 if (dds == DE_NULL)
405 TCU_THROW(InternalError, "Undefined device driver for Vulkan SC");
406 dds->reset();
407 m_resourceInterface->resetObjects();
408
409 suppressStandardOutput();
410 m_context->getTestContext().getLog().supressLogging(true);
411 }
412 m_subprocessCount = currentSubprocessCount;
413 #endif // CTS_USES_VULKANSC
414 m_testsForSubprocess.push_back(casePath);
415 }
416
417 m_resourceInterface->initTestCase(casePath);
418
419 if (m_waiverMechanism.isOnWaiverList(casePath))
420 throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
421
422 vktCase->checkSupport(*m_context);
423
424 vktCase->delayedInit();
425
426 m_progCollection.clear();
427 vktCase->initPrograms(sourceProgs);
428
429 for (vk::GlslSourceCollection::Iterator progIter = sourceProgs.glslSources.begin(); progIter != sourceProgs.glslSources.end(); ++progIter)
430 {
431 if (!spirvVersionSupported(progIter.getProgram().buildOptions.targetVersion))
432 TCU_THROW(NotSupportedError, "Shader requires SPIR-V higher than available");
433
434 const vk::ProgramBinary* const binProg = m_resourceInterface->buildProgram<glu::ShaderProgramInfo, vk::GlslSourceCollection::Iterator>(casePath, progIter, m_prebuiltBinRegistry, &m_progCollection);
435
436 if (doShaderLog)
437 {
438 try
439 {
440 std::ostringstream disasm;
441
442 vk::disassembleProgram(*binProg, &disasm);
443
444 log << vk::SpirVAsmSource(disasm.str());
445 }
446 catch (const tcu::NotSupportedError& err)
447 {
448 log << err;
449 }
450 }
451 }
452
453 for (vk::HlslSourceCollection::Iterator progIter = sourceProgs.hlslSources.begin(); progIter != sourceProgs.hlslSources.end(); ++progIter)
454 {
455 if (!spirvVersionSupported(progIter.getProgram().buildOptions.targetVersion))
456 TCU_THROW(NotSupportedError, "Shader requires SPIR-V higher than available");
457
458 const vk::ProgramBinary* const binProg = m_resourceInterface->buildProgram<glu::ShaderProgramInfo, vk::HlslSourceCollection::Iterator>(casePath, progIter, m_prebuiltBinRegistry, &m_progCollection);
459
460 if (doShaderLog)
461 {
462 try
463 {
464 std::ostringstream disasm;
465
466 vk::disassembleProgram(*binProg, &disasm);
467
468 log << vk::SpirVAsmSource(disasm.str());
469 }
470 catch (const tcu::NotSupportedError& err)
471 {
472 log << err;
473 }
474 }
475 }
476
477 for (vk::SpirVAsmCollection::Iterator asmIterator = sourceProgs.spirvAsmSources.begin(); asmIterator != sourceProgs.spirvAsmSources.end(); ++asmIterator)
478 {
479 if (!spirvVersionSupported(asmIterator.getProgram().buildOptions.targetVersion))
480 TCU_THROW(NotSupportedError, "Shader requires SPIR-V higher than available");
481
482 m_resourceInterface->buildProgram<vk::SpirVProgramInfo, vk::SpirVAsmCollection::Iterator>(casePath, asmIterator, m_prebuiltBinRegistry, &m_progCollection);
483 }
484
485 if (m_renderDoc) m_renderDoc->startFrame(m_context->getInstance());
486
487 DE_ASSERT(!m_instance);
488 m_instance = vktCase->createInstance(*m_context);
489 m_context->resultSetOnValidation(false);
490 }
491
deinit(tcu::TestCase * testCase)492 void TestCaseExecutor::deinit (tcu::TestCase* testCase)
493 {
494 delete m_instance;
495 m_instance = DE_NULL;
496
497 if (m_renderDoc) m_renderDoc->endFrame(m_context->getInstance());
498
499 // Collect and report any debug messages
500 #ifndef CTS_USES_VULKANSC
501 if (m_context->hasDebugReportRecorder())
502 collectAndReportDebugMessages(m_context->getDebugReportRecorder(), *m_context);
503 #endif // CTS_USES_VULKANSC
504
505 if (testCase != DE_NULL)
506 logUnusedShaders(testCase);
507
508 #ifdef CTS_USES_VULKANSC
509 if (!m_context->getTestContext().getCommandLine().isSubProcess())
510 {
511 int currentSubprocessCount = getCurrentSubprocessCount(m_context->getResourceInterface()->getCasePath(), m_context->getTestContext().getCommandLine().getSubprocessTestCount());
512 if (m_testsForSubprocess.size() >= std::size_t(currentSubprocessCount))
513 {
514 runTestsInSubprocess(m_context->getTestContext());
515
516 // Clean up data after performing tests in subprocess and prepare system for another batch of tests
517 m_testsForSubprocess.clear();
518 const vk::DeviceInterface& vkd = m_context->getDeviceInterface();
519 const vk::DeviceDriverSC* dds = dynamic_cast<const vk::DeviceDriverSC*>(&vkd);
520 if (dds == DE_NULL)
521 TCU_THROW(InternalError, "Undefined device driver for Vulkan SC");
522 dds->reset();
523 m_resourceInterface->resetObjects();
524
525 suppressStandardOutput();
526 m_context->getTestContext().getLog().supressLogging(true);
527 }
528 }
529 #endif // CTS_USES_VULKANSC
530 }
531
logUnusedShaders(tcu::TestCase * testCase)532 void TestCaseExecutor::logUnusedShaders (tcu::TestCase* testCase)
533 {
534 const qpTestResult testResult = testCase->getTestContext().getTestResult();
535
536 if (testResult == QP_TEST_RESULT_PASS || testResult == QP_TEST_RESULT_QUALITY_WARNING || testResult == QP_TEST_RESULT_COMPATIBILITY_WARNING)
537 {
538 bool unusedShaders = false;
539
540 for (vk::BinaryCollection::Iterator it = m_progCollection.begin(); it != m_progCollection.end(); ++it)
541 {
542 if (!it.getProgram().getUsed())
543 {
544 unusedShaders = true;
545
546 break;
547 }
548 }
549
550 if (unusedShaders)
551 {
552 std::string message;
553
554 for (vk::BinaryCollection::Iterator it = m_progCollection.begin(); it != m_progCollection.end(); ++it)
555 {
556 if (!it.getProgram().getUsed())
557 message += it.getName() + ",";
558 }
559
560 message.resize(message.size() - 1);
561
562 message = std::string("Unused shaders: ") + message;
563
564 m_context->getTestContext().getLog() << TestLog::Message << message << TestLog::EndMessage;
565 }
566 }
567 }
568
iterate(tcu::TestCase *)569 tcu::TestNode::IterateResult TestCaseExecutor::iterate (tcu::TestCase*)
570 {
571 DE_ASSERT(m_instance);
572
573 const tcu::TestStatus result = m_instance->iterate();
574
575 if (result.isComplete())
576 {
577 // Vulkan tests shouldn't set result directly except when using a debug report messenger to catch validation errors.
578 DE_ASSERT(m_context->getTestContext().getTestResult() == QP_TEST_RESULT_LAST || m_context->resultSetOnValidation());
579
580 // Override result if not set previously by a debug report messenger.
581 if (!m_context->resultSetOnValidation())
582 m_context->getTestContext().setTestResult(result.getCode(), result.getDescription().c_str());
583 return tcu::TestNode::STOP;
584 }
585 else
586 return tcu::TestNode::CONTINUE;
587 }
588
deinitTestPackage(tcu::TestContext & testCtx)589 void TestCaseExecutor::deinitTestPackage (tcu::TestContext& testCtx)
590 {
591 #ifdef CTS_USES_VULKANSC
592 if (!testCtx.getCommandLine().isSubProcess())
593 {
594 if (!m_testsForSubprocess.empty())
595 {
596 runTestsInSubprocess(testCtx);
597
598 // Clean up data after performing tests in subprocess and prepare system for another batch of tests
599 m_testsForSubprocess.clear();
600 const vk::DeviceInterface& vkd = m_context->getDeviceInterface();
601 const vk::DeviceDriverSC* dds = dynamic_cast<const vk::DeviceDriverSC*>(&vkd);
602 if (dds == DE_NULL)
603 TCU_THROW(InternalError, "Undefined device driver for Vulkan SC");
604 dds->reset();
605 m_resourceInterface->resetObjects();
606 }
607
608 // Tests are finished. Next tests ( if any ) will come from other test package and test executor
609 restoreStandardOutput();
610 m_context->getTestContext().getLog().supressLogging(false);
611 }
612 m_resourceInterface->resetPipelineCaches();
613 #else
614 DE_UNREF(testCtx);
615 #endif // CTS_USES_VULKANSC
616 }
617
usesLocalStatus()618 bool TestCaseExecutor::usesLocalStatus ()
619 {
620 #ifdef CTS_USES_VULKANSC
621 return !m_context->getTestContext().getCommandLine().isSubProcess();
622 #else
623 return false;
624 #endif
625 }
626
updateGlobalStatus(tcu::TestRunStatus & status)627 void TestCaseExecutor::updateGlobalStatus (tcu::TestRunStatus& status)
628 {
629 status.numExecuted += m_status.numExecuted;
630 status.numPassed += m_status.numPassed;
631 status.numNotSupported += m_status.numNotSupported;
632 status.numWarnings += m_status.numWarnings;
633 status.numWaived += m_status.numWaived;
634 status.numFailed += m_status.numFailed;
635 m_status.clear();
636 }
637
reportDurations(tcu::TestContext & testCtx,const std::string & packageName,const deInt64 & duration,const std::map<std::string,deUint64> & groupsDurationTime)638 void TestCaseExecutor::reportDurations(tcu::TestContext& testCtx, const std::string& packageName, const deInt64& duration, const std::map<std::string, deUint64>& groupsDurationTime)
639 {
640 #ifdef CTS_USES_VULKANSC
641 // Send it to server to append to its log
642 vksc_server::AppendRequest request;
643 request.fileName = testCtx.getCommandLine().getLogFileName();
644
645 std::ostringstream str;
646
647 str << std::endl;
648 str << "#beginTestsCasesTime" << std::endl;
649
650 str << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
651 str << "<TestsCasesTime>" << std::endl;
652
653 str << " <Number Name=\"" << packageName << "\" Description=\"Total tests case duration in microseconds\" Tag=\"Time\" Unit=\"us\">" << duration << "</Number>" << std::endl;
654 for (std::map<std::string, deUint64>::const_iterator it = groupsDurationTime.begin(); it != groupsDurationTime.end(); ++it)
655 str << " <Number Name=\"" << it->first << "\" Description=\"The test group case duration in microseconds\" Tag=\"Time\" Unit=\"us\">" << it->second << "</Number>" << std::endl;
656 str << "</TestsCasesTime>" << std::endl;
657 str << std::endl;
658 str << "#endTestsCasesTime" << std::endl;
659 str << std::endl;
660 str << "#endSession" << std::endl;
661
662 std::string output = str.str();
663 request.data.assign(output.begin(), output.end());
664 vksc_server::StandardOutputServerSingleton()->SendRequest(request);
665 #else
666 DE_UNREF(testCtx);
667 DE_UNREF(packageName);
668 DE_UNREF(duration);
669 DE_UNREF(groupsDurationTime);
670 #endif // CTS_USES_VULKANSC
671
672 }
673
getCurrentSubprocessCount(const std::string & casePath,int defaultSubprocessCount)674 int TestCaseExecutor::getCurrentSubprocessCount(const std::string& casePath, int defaultSubprocessCount)
675 {
676 #ifdef CTS_USES_VULKANSC
677 for (const auto& detailed : m_detailedSubprocessTestCount)
678 if (tcu::matchWildcards(detailed.testPattern.begin(), detailed.testPattern.end(), casePath.begin(), casePath.end(), false))
679 return detailed.testCount;
680 #else
681 DE_UNREF(casePath);
682 #endif // CTS_USES_VULKANSC
683 return defaultSubprocessCount;
684 }
685
runTestsInSubprocess(tcu::TestContext & testCtx)686 void TestCaseExecutor::runTestsInSubprocess (tcu::TestContext& testCtx)
687 {
688 #ifdef CTS_USES_VULKANSC
689 if (testCtx.getCommandLine().isSubProcess())
690 TCU_THROW(InternalError, "Cannot run subprocess inside subprocess : ");
691
692 if (m_testsForSubprocess.empty())
693 return;
694
695 std::vector<int> caseFraction = testCtx.getCommandLine().getCaseFraction();
696 std::ostringstream jsonFileName, qpaFileName, pipelineCompilerOutFileName, pipelineCompilerLogFileName, pipelineCompilerPrefix;
697 if (caseFraction.empty())
698 {
699 jsonFileName << "pipeline_data.txt";
700 qpaFileName << "sub.qpa";
701 if (!std::string(testCtx.getCommandLine().getPipelineCompilerPath()).empty())
702 {
703 pipelineCompilerOutFileName << "pipeline_cache.bin";
704 pipelineCompilerLogFileName << "compiler.log";
705 pipelineCompilerPrefix << "";
706 }
707 }
708 else
709 {
710 jsonFileName << "pipeline_data_" << caseFraction[0] << ".txt";
711 qpaFileName << "sub_" << caseFraction[0] << ".qpa";
712 if (!std::string(testCtx.getCommandLine().getPipelineCompilerPath()).empty())
713 {
714 pipelineCompilerOutFileName << "pipeline_cache_" << caseFraction[0] <<".bin";
715 pipelineCompilerLogFileName << "compiler_" << caseFraction[0] << ".log";
716 pipelineCompilerPrefix << "sub_" << caseFraction[0] << "_";
717 }
718 }
719
720 // export data collected during statistics gathering to JSON file ( VkDeviceObjectReservationCreateInfo, SPIR-V shaders, pipelines )
721 {
722 m_resourceInterface->removeRedundantObjects();
723 m_resourceInterface->finalizeCommandBuffers();
724 std::vector<deUint8> data = m_resourceInterface->exportData();
725 m_parentIPC->SetFile(jsonFileName.str(), data);
726 }
727
728 // collect current application name, add it to new commandline with subprocess parameters
729 std::string newCmdLine;
730 {
731 std::string appName = testCtx.getCommandLine().getApplicationName();
732 if (appName.empty())
733 TCU_THROW(InternalError, "Application name is not defined");
734 // add --deqp-subprocess option to inform deqp-vksc process that it works as slave process
735 newCmdLine = appName + " --deqp-subprocess=enable --deqp-log-filename=" + qpaFileName.str();
736
737 // add offline pipeline compiler parameters if present
738 if (!std::string(testCtx.getCommandLine().getPipelineCompilerPath()).empty())
739 {
740 newCmdLine += " --deqp-pipeline-compiler=" + std::string(testCtx.getCommandLine().getPipelineCompilerPath());
741 newCmdLine += " --deqp-pipeline-file=" + pipelineCompilerOutFileName.str();
742 if (!std::string(testCtx.getCommandLine().getPipelineCompilerDataDir()).empty())
743 newCmdLine += " --deqp-pipeline-dir=" + std::string(testCtx.getCommandLine().getPipelineCompilerDataDir());
744 newCmdLine += " --deqp-pipeline-logfile=" + pipelineCompilerLogFileName.str();
745 if(!pipelineCompilerPrefix.str().empty())
746 newCmdLine += " --deqp-pipeline-prefix=" + pipelineCompilerPrefix.str();
747 if (!std::string(testCtx.getCommandLine().getPipelineCompilerArgs()).empty())
748 newCmdLine += " --deqp-pipeline-args=\"" + std::string( testCtx.getCommandLine().getPipelineCompilerArgs() ) + "\"";
749 }
750 }
751
752 // collect parameters, remove parameters associated with case filter and case fraction. We will provide our own case list
753 {
754 std::string originalCmdLine = testCtx.getCommandLine().getInitialCmdLine();
755
756 // brave ( but working ) assumption that each CTS parameter starts with "--deqp"
757
758 std::string paramStr ("--deqp");
759 std::vector<std::string> skipElements =
760 {
761 "--deqp-case",
762 "--deqp-stdin-caselist",
763 "--deqp-log-filename",
764 "--deqp-pipeline-compiler",
765 "--deqp-pipeline-dir",
766 "--deqp-pipeline-args",
767 "--deqp-pipeline-file",
768 "--deqp-pipeline-logfile",
769 "--deqp-pipeline-prefix"
770 };
771
772 std::size_t pos = 0;
773 std::vector<std::size_t> argPos;
774 while ((pos = originalCmdLine.find(paramStr, pos)) != std::string::npos)
775 argPos.push_back(pos++);
776 if (!argPos.empty())
777 argPos.push_back(originalCmdLine.size());
778
779 std::vector<std::string> args;
780 for (std::size_t i = 0; i < argPos.size()-1; ++i)
781 {
782 std::string s = originalCmdLine.substr(argPos[i], argPos[i + 1] - argPos[i]);
783 std::size_t found = s.find_last_not_of(' ');
784 if (found != std::string::npos)
785 {
786 s.erase(found + 1);
787 args.push_back(s);
788 }
789 }
790 for (std::size_t i = 0; i < args.size(); ++i)
791 {
792 bool skipElement = false;
793 for (const auto& elem : skipElements)
794 if (args[i].find(elem) == 0)
795 {
796 skipElement = true;
797 break;
798 }
799 if (skipElement)
800 continue;
801 newCmdLine = newCmdLine + " " + args[i];
802 }
803 }
804
805 // create --deqp-case list from tests collected in m_testsForSubprocess
806 std::string subprocessTestList;
807 for (auto it = begin(m_testsForSubprocess); it != end(m_testsForSubprocess); ++it)
808 {
809 auto nit = it; ++nit;
810
811 subprocessTestList += *it;
812 if (nit != end(m_testsForSubprocess))
813 subprocessTestList += "\n";
814 }
815
816 std::string caseListName = "subcaselist" + (caseFraction.empty() ? std::string("") : de::toString(caseFraction[0])) + ".txt";
817
818 deFile* exportFile = deFile_create(caseListName.c_str(), DE_FILEMODE_CREATE | DE_FILEMODE_OPEN | DE_FILEMODE_WRITE | DE_FILEMODE_TRUNCATE);
819 deInt64 numWritten = 0;
820 deFile_write(exportFile, subprocessTestList.c_str(), subprocessTestList.size(), &numWritten);
821 deFile_destroy(exportFile);
822 newCmdLine = newCmdLine + " --deqp-caselist-file=" + caseListName;
823
824 // restore cout and cerr
825 restoreStandardOutput();
826
827 // create subprocess which will perform real tests
828 std::string subProcessExitCodeInfo;
829 {
830 deProcess* process = deProcess_create();
831 if (deProcess_start(process, newCmdLine.c_str(), ".") != DE_TRUE)
832 {
833 std::string err = deProcess_getLastError(process);
834 deProcess_destroy(process);
835 process = DE_NULL;
836 TCU_THROW(InternalError, "Error while running subprocess : " + err);
837 }
838 std::string whole;
839 whole.reserve(1024 * 4);
840
841 // create a separate thread that captures std::err output
842 de::MovePtr<std::thread> errThread(new std::thread([&process]
843 {
844 deFile* subErr = deProcess_getStdErr(process);
845 char errBuffer[128] = { 0 };
846 deInt64 errNumRead = 0;
847 while (deFile_read(subErr, errBuffer, sizeof(errBuffer) - 1, &errNumRead) == DE_FILERESULT_SUCCESS)
848 {
849 errBuffer[errNumRead] = 0;
850 }
851 }));
852
853 deFile* subOutput = deProcess_getStdOut(process);
854 char outBuffer[128] = { 0 };
855 deInt64 numRead = 0;
856 while (deFile_read(subOutput, outBuffer, sizeof(outBuffer) - 1, &numRead) == DE_FILERESULT_SUCCESS)
857 {
858 outBuffer[numRead] = 0;
859 qpPrint(outBuffer);
860 whole += outBuffer;
861 }
862 errThread->join();
863 if (deProcess_waitForFinish(process))
864 {
865 const int exitCode = deProcess_getExitCode(process);
866 std::stringstream s;
867
868 s << " Subprocess failed with exit code " << exitCode << "(" << std::hex << exitCode << ")";
869
870 subProcessExitCodeInfo = s.str();
871 }
872 deProcess_destroy(process);
873
874 vksc_server::RemoteWrite(0, whole.c_str());
875 }
876
877 // copy test information from sub.qpa to main log
878 {
879 std::ifstream subQpa(qpaFileName.str(), std::ios::binary);
880 std::string subQpaText{std::istreambuf_iterator<char>(subQpa),
881 std::istreambuf_iterator<char>()};
882 {
883 std::string beginText ("#beginTestCaseResult");
884 std::string endText ("#endTestCaseResult");
885 std::size_t beginPos = subQpaText.find(beginText);
886 std::size_t endPos = subQpaText.rfind(endText);
887 if (beginPos == std::string::npos || endPos == std::string::npos)
888 TCU_THROW(InternalError, "Couldn't match tags from " + qpaFileName.str() + subProcessExitCodeInfo);
889
890 std::string subQpaCopy = "\n" + std::string(subQpaText.begin() + beginPos, subQpaText.begin() + endPos + endText.size()) + "\n";
891
892 if (!std::string(testCtx.getCommandLine().getServerAddress()).empty())
893 {
894 // Send it to server to append to its log
895 vksc_server::AppendRequest request;
896 request.fileName = testCtx.getCommandLine().getLogFileName();
897 request.data.assign(subQpaCopy.begin(), subQpaCopy.end());
898 vksc_server::StandardOutputServerSingleton()->SendRequest(request);
899 }
900 else
901 {
902 // Write it to parent's log
903 try
904 {
905 testCtx.getLog().supressLogging(false);
906 testCtx.getLog().writeRaw(subQpaCopy.c_str());
907 }
908 catch(...)
909 {
910 testCtx.getLog().supressLogging(true);
911 throw;
912 }
913 testCtx.getLog().supressLogging(true);
914 }
915 }
916
917 {
918 std::string beginStat ("#SubProcessStatus");
919 std::size_t beginPos = subQpaText.find(beginStat);
920 if (beginPos == std::string::npos)
921 TCU_THROW(InternalError, "Couldn't match #SubProcessStatus tag from " + qpaFileName.str() + subProcessExitCodeInfo);
922
923 std::string subQpaStat (subQpaText.begin() + beginPos + beginStat.size(), subQpaText.end());
924
925 std::istringstream str(subQpaStat);
926 int numExecuted, numPassed, numFailed, numNotSupported, numWarnings, numWaived;
927 str >> numExecuted >> numPassed >> numFailed >> numNotSupported >> numWarnings >> numWaived;
928
929 m_status.numExecuted += numExecuted;
930 m_status.numPassed += numPassed;
931 m_status.numNotSupported += numNotSupported;
932 m_status.numWarnings += numWarnings;
933 m_status.numWaived += numWaived;
934 m_status.numFailed += numFailed;
935 }
936
937 deDeleteFile(qpaFileName.str().c_str());
938 }
939 #else
940 DE_UNREF(testCtx);
941 #endif // CTS_USES_VULKANSC
942 }
943
spirvVersionSupported(vk::SpirvVersion spirvVersion)944 bool TestCaseExecutor::spirvVersionSupported (vk::SpirvVersion spirvVersion)
945 {
946 if (spirvVersion <= vk::getMaxSpirvVersionForVulkan(m_context->getUsedApiVersion()))
947 return true;
948
949 if (spirvVersion <= vk::SPIRV_VERSION_1_4)
950 return m_context->isDeviceFunctionalitySupported("VK_KHR_spirv_1_4");
951
952 return false;
953 }
954
955 // GLSL shader tests
956
createGlslTests(tcu::TestCaseGroup * glslTests)957 void createGlslTests (tcu::TestCaseGroup* glslTests)
958 {
959 tcu::TestContext& testCtx = glslTests->getTestContext();
960
961 // ShaderLibrary-based tests
962 static const struct
963 {
964 const char* name;
965 const char* description;
966 } s_es310Tests[] =
967 {
968 { "arrays", "Arrays" },
969 { "conditionals", "Conditional statements" },
970 { "constant_expressions", "Constant expressions" },
971 { "constants", "Constants" },
972 { "conversions", "Type conversions" },
973 { "functions", "Functions" },
974 { "linkage", "Linking" },
975 { "scoping", "Scoping" },
976 { "swizzles", "Swizzles" },
977 };
978
979 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_es310Tests); ndx++)
980 glslTests->addChild(createShaderLibraryGroup(testCtx,
981 s_es310Tests[ndx].name,
982 s_es310Tests[ndx].description,
983 std::string("vulkan/glsl/es310/") + s_es310Tests[ndx].name + ".test").release());
984
985 static const struct
986 {
987 const char* name;
988 const char* description;
989 } s_440Tests[] =
990 {
991 { "linkage", "Linking" },
992 };
993
994 de::MovePtr<tcu::TestCaseGroup> glsl440Tests = de::MovePtr<tcu::TestCaseGroup>(new tcu::TestCaseGroup(testCtx, "440", ""));
995
996 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_440Tests); ndx++)
997 glsl440Tests->addChild(createShaderLibraryGroup(testCtx,
998 s_440Tests[ndx].name,
999 s_440Tests[ndx].description,
1000 std::string("vulkan/glsl/440/") + s_440Tests[ndx].name + ".test").release());
1001
1002 glslTests->addChild(glsl440Tests.release());
1003
1004 // ShaderRenderCase-based tests
1005 glslTests->addChild(sr::createDerivateTests (testCtx));
1006 glslTests->addChild(sr::createDiscardTests (testCtx));
1007 #ifndef CTS_USES_VULKANSC
1008 glslTests->addChild(sr::createDemoteTests (testCtx));
1009 #endif // CTS_USES_VULKANSC
1010 glslTests->addChild(sr::createIndexingTests (testCtx));
1011 glslTests->addChild(sr::createShaderInvarianceTests (testCtx));
1012 glslTests->addChild(sr::createLimitTests (testCtx));
1013 glslTests->addChild(sr::createLoopTests (testCtx));
1014 glslTests->addChild(sr::createMatrixTests (testCtx));
1015 glslTests->addChild(sr::createOperatorTests (testCtx));
1016 glslTests->addChild(sr::createReturnTests (testCtx));
1017 glslTests->addChild(sr::createStructTests (testCtx));
1018 glslTests->addChild(sr::createSwitchTests (testCtx));
1019 glslTests->addChild(sr::createTextureFunctionTests (testCtx));
1020 glslTests->addChild(sr::createTextureGatherTests (testCtx));
1021 glslTests->addChild(sr::createBuiltinVarTests (testCtx));
1022
1023 // ShaderExecutor-based tests
1024 glslTests->addChild(shaderexecutor::createBuiltinTests (testCtx));
1025 glslTests->addChild(shaderexecutor::createOpaqueTypeIndexingTests (testCtx));
1026 glslTests->addChild(shaderexecutor::createAtomicOperationTests (testCtx));
1027 glslTests->addChild(shaderexecutor::createShaderClockTests (testCtx));
1028
1029 #ifndef CTS_USES_VULKANSC
1030 // Amber GLSL tests.
1031 glslTests->addChild(cts_amber::createCombinedOperationsGroup (testCtx));
1032 glslTests->addChild(cts_amber::createCrashTestGroup (testCtx));
1033 #endif // CTS_USES_VULKANSC
1034 }
1035
1036 // TestPackage
1037
BaseTestPackage(tcu::TestContext & testCtx,const char * name,const char * desc)1038 BaseTestPackage::BaseTestPackage (tcu::TestContext& testCtx, const char* name, const char* desc)
1039 : tcu::TestPackage(testCtx, name, desc)
1040 {
1041 }
1042
~BaseTestPackage(void)1043 BaseTestPackage::~BaseTestPackage (void)
1044 {
1045 }
1046
1047 #ifdef CTS_USES_VULKAN
1048
TestPackage(tcu::TestContext & testCtx)1049 TestPackage::TestPackage (tcu::TestContext& testCtx)
1050 : BaseTestPackage(testCtx, "dEQP-VK", "dEQP Vulkan Tests")
1051 {
1052 }
1053
~TestPackage(void)1054 TestPackage::~TestPackage (void)
1055 {
1056 }
1057
ExperimentalTestPackage(tcu::TestContext & testCtx)1058 ExperimentalTestPackage::ExperimentalTestPackage (tcu::TestContext& testCtx)
1059 : BaseTestPackage(testCtx, "dEQP-VK-experimental", "dEQP Vulkan Experimental Tests")
1060 {
1061 }
1062
~ExperimentalTestPackage(void)1063 ExperimentalTestPackage::~ExperimentalTestPackage (void)
1064 {
1065 }
1066
1067 #endif
1068
1069 #ifdef CTS_USES_VULKANSC
1070
TestPackageSC(tcu::TestContext & testCtx)1071 TestPackageSC::TestPackageSC (tcu::TestContext& testCtx)
1072 : BaseTestPackage(testCtx, "dEQP-VKSC", "dEQP Vulkan SC Tests")
1073 {
1074 }
1075
~TestPackageSC(void)1076 TestPackageSC::~TestPackageSC (void)
1077 {
1078 }
1079
1080 #endif // CTS_USES_VULKANSC
1081
createExecutor(void) const1082 tcu::TestCaseExecutor* BaseTestPackage::createExecutor (void) const
1083 {
1084 return new TestCaseExecutor(m_testCtx);
1085 }
1086
1087 #ifdef CTS_USES_VULKAN
1088
init(void)1089 void TestPackage::init (void)
1090 {
1091 addChild(createTestGroup (m_testCtx, "info", "Build and Device Info Tests", createInfoTests));
1092 addChild(api::createTests (m_testCtx));
1093 addChild(memory::createTests (m_testCtx));
1094 addChild(pipeline::createTests (m_testCtx));
1095 addChild(BindingModel::createTests (m_testCtx));
1096 addChild(SpirVAssembly::createTests (m_testCtx));
1097 addChild(createTestGroup (m_testCtx, "glsl", "GLSL shader execution tests", createGlslTests));
1098 addChild(createRenderPassTests (m_testCtx));
1099 addChild(createRenderPass2Tests (m_testCtx));
1100 addChild(createDynamicRenderingTests (m_testCtx));
1101 addChild(ubo::createTests (m_testCtx));
1102 addChild(DynamicState::createTests (m_testCtx));
1103 addChild(ssbo::createTests (m_testCtx));
1104 addChild(QueryPool::createTests (m_testCtx));
1105 addChild(Draw::createTests (m_testCtx));
1106 addChild(compute::createTests (m_testCtx));
1107 addChild(image::createTests (m_testCtx));
1108 addChild(wsi::createTests (m_testCtx));
1109 addChild(createSynchronizationTests (m_testCtx));
1110 addChild(createSynchronization2Tests (m_testCtx));
1111 addChild(sparse::createTests (m_testCtx));
1112 addChild(tessellation::createTests (m_testCtx));
1113 addChild(rasterization::createTests (m_testCtx));
1114 addChild(clipping::createTests (m_testCtx));
1115 addChild(FragmentOperations::createTests (m_testCtx));
1116 addChild(texture::createTests (m_testCtx));
1117 addChild(geometry::createTests (m_testCtx));
1118 addChild(robustness::createTests (m_testCtx));
1119 addChild(MultiView::createTests (m_testCtx));
1120 addChild(subgroups::createTests (m_testCtx));
1121 addChild(ycbcr::createTests (m_testCtx));
1122 addChild(ProtectedMem::createTests (m_testCtx));
1123 addChild(DeviceGroup::createTests (m_testCtx));
1124 addChild(MemoryModel::createTests (m_testCtx));
1125 addChild(conditional::createTests (m_testCtx));
1126 addChild(cts_amber::createGraphicsFuzzTests (m_testCtx));
1127 addChild(imageless::createTests (m_testCtx));
1128 addChild(TransformFeedback::createTests (m_testCtx));
1129 addChild(DescriptorIndexing::createTests (m_testCtx));
1130 addChild(FragmentShaderInterlock::createTests(m_testCtx));
1131 addChild(modifiers::createTests (m_testCtx));
1132 addChild(RayTracing::createTests (m_testCtx));
1133 addChild(RayQuery::createTests (m_testCtx));
1134 addChild(FragmentShadingRate::createTests (m_testCtx));
1135 addChild(Reconvergence::createTests (m_testCtx, false));
1136 addChild(MeshShader::createTests (m_testCtx));
1137 addChild(FragmentShadingBarycentric::createTests(m_testCtx));
1138 // Amber depth pipeline tests
1139 addChild(cts_amber::createAmberDepthGroup (m_testCtx));
1140 addChild(video::createTests (m_testCtx));
1141 }
1142
init(void)1143 void ExperimentalTestPackage::init (void)
1144 {
1145 addChild(postmortem::createTests (m_testCtx));
1146 addChild(Reconvergence::createTests (m_testCtx, true));
1147 }
1148
1149 #endif
1150
1151 #ifdef CTS_USES_VULKANSC
1152
init(void)1153 void TestPackageSC::init (void)
1154 {
1155 addChild(createTestGroup (m_testCtx, "info", "Build and Device Info Tests", createInfoTests));
1156 addChild(api::createTests (m_testCtx));
1157 addChild(memory::createTests (m_testCtx));
1158 addChild(pipeline::createTests (m_testCtx));
1159 addChild(BindingModel::createTests (m_testCtx));
1160 addChild(SpirVAssembly::createTests (m_testCtx));
1161 addChild(createTestGroup (m_testCtx, "glsl", "GLSL shader execution tests", createGlslTests));
1162 addChild(createRenderPassTests (m_testCtx));
1163 addChild(createRenderPass2Tests (m_testCtx));
1164 addChild(ubo::createTests (m_testCtx));
1165 addChild(DynamicState::createTests (m_testCtx));
1166 addChild(ssbo::createTests (m_testCtx));
1167 addChild(QueryPool::createTests (m_testCtx));
1168 addChild(Draw::createTests (m_testCtx));
1169 addChild(compute::createTests (m_testCtx));
1170 addChild(image::createTests (m_testCtx));
1171 // addChild(wsi::createTests (m_testCtx));
1172 addChild(createSynchronizationTests (m_testCtx));
1173 addChild(createSynchronization2Tests (m_testCtx));
1174 // addChild(sparse::createTests (m_testCtx));
1175 addChild(tessellation::createTests (m_testCtx));
1176 addChild(rasterization::createTests (m_testCtx));
1177 addChild(clipping::createTests (m_testCtx));
1178 addChild(FragmentOperations::createTests (m_testCtx));
1179 addChild(texture::createTests (m_testCtx));
1180 addChild(geometry::createTests (m_testCtx));
1181 addChild(robustness::createTests (m_testCtx));
1182 addChild(MultiView::createTests (m_testCtx));
1183 addChild(subgroups::createTests (m_testCtx));
1184 addChild(ycbcr::createTests (m_testCtx));
1185 addChild(ProtectedMem::createTests (m_testCtx));
1186 addChild(DeviceGroup::createTests (m_testCtx));
1187 addChild(MemoryModel::createTests (m_testCtx));
1188 // addChild(conditional::createTests (m_testCtx));
1189 // addChild(cts_amber::createGraphicsFuzzTests (m_testCtx));
1190 addChild(imageless::createTests (m_testCtx));
1191 // addChild(TransformFeedback::createTests (m_testCtx));
1192 addChild(DescriptorIndexing::createTests (m_testCtx));
1193 addChild(FragmentShaderInterlock::createTests(m_testCtx));
1194 // addChild(modifiers::createTests (m_testCtx));
1195 // addChild(RayTracing::createTests (m_testCtx));
1196 // addChild(RayQuery::createTests (m_testCtx));
1197 addChild(FragmentShadingRate::createTests(m_testCtx));
1198 addChild(sc::createTests(m_testCtx));
1199 }
1200
1201 #endif // CTS_USES_VULKANSC
1202
1203 } // vkt
1204