1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2021 The Khronos Group Inc.
6 * Copyright (c) 2021 Valve Corporation.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief Tests using non-uniform arguments with traceRayExt().
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktRayQueryNonUniformArgsTests.hpp"
26 #include "vktTestCase.hpp"
27
28 #include "vkRayTracingUtil.hpp"
29 #include "vkObjUtil.hpp"
30 #include "vkCmdUtil.hpp"
31 #include "vkBuilderUtil.hpp"
32 #include "vkTypeUtil.hpp"
33 #include "vkBarrierUtil.hpp"
34
35 #include "tcuTestLog.hpp"
36
37 #include <vector>
38 #include <iostream>
39
40 namespace vkt
41 {
42 namespace RayQuery
43 {
44 namespace
45 {
46
47 using namespace vk;
48
49 // Causes for hitting the miss shader due to argument values.
50 enum class MissCause
51 {
52 NONE = 0,
53 FLAGS,
54 CULL_MASK,
55 ORIGIN,
56 TMIN,
57 DIRECTION,
58 TMAX,
59 CAUSE_COUNT,
60 };
61
62 struct NonUniformParams
63 {
64 MissCause missCause;
65 };
66
67 class NonUniformArgsCase : public TestCase
68 {
69 public:
70 NonUniformArgsCase(tcu::TestContext &testCtx, const std::string &name, const NonUniformParams ¶ms);
~NonUniformArgsCase(void)71 virtual ~NonUniformArgsCase(void)
72 {
73 }
74
75 virtual void checkSupport(Context &context) const;
76 virtual void initPrograms(vk::SourceCollections &programCollection) const;
77 virtual TestInstance *createInstance(Context &context) const;
78
79 protected:
80 NonUniformParams m_params;
81 };
82
83 class NonUniformArgsInstance : public TestInstance
84 {
85 public:
86 NonUniformArgsInstance(Context &context, const NonUniformParams ¶ms);
~NonUniformArgsInstance(void)87 virtual ~NonUniformArgsInstance(void)
88 {
89 }
90
91 virtual tcu::TestStatus iterate(void);
92
93 protected:
94 NonUniformParams m_params;
95 };
96
NonUniformArgsCase(tcu::TestContext & testCtx,const std::string & name,const NonUniformParams & params)97 NonUniformArgsCase::NonUniformArgsCase(tcu::TestContext &testCtx, const std::string &name,
98 const NonUniformParams ¶ms)
99 : TestCase(testCtx, name)
100 , m_params(params)
101 {
102 }
103
checkSupport(Context & context) const104 void NonUniformArgsCase::checkSupport(Context &context) const
105 {
106 context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
107 context.requireDeviceFunctionality("VK_KHR_ray_query");
108 }
109
110 struct ArgsBufferData
111 {
112 tcu::Vec4 origin;
113 tcu::Vec4 direction;
114 float Tmin;
115 float Tmax;
116 uint32_t rayFlags;
117 uint32_t cullMask;
118 };
119
initPrograms(vk::SourceCollections & programCollection) const120 void NonUniformArgsCase::initPrograms(vk::SourceCollections &programCollection) const
121 {
122 const ShaderBuildOptions buildOptions(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
123
124 std::ostringstream comp;
125 comp << "#version 460 core\n"
126 << "#extension GL_EXT_ray_query : require\n"
127 << "\n"
128 << "layout(local_size_x=1, local_size_y=1, local_size_z=1) in;\n"
129 << "\n"
130 << "layout(set=0, binding=0) uniform accelerationStructureEXT topLevelAS;\n"
131 << "layout(set=0, binding=1, std430) buffer ArgumentsBlock {\n" // Must match ArgsBufferData.
132 << " vec4 origin;\n"
133 << " vec4 direction;\n"
134 << " float Tmin;\n"
135 << " float Tmax;\n"
136 << " uint rayFlags;\n"
137 << " uint cullMask;\n"
138 << "} args;\n"
139 << "layout(set=0, binding=2, std430) buffer ResultBlock {\n"
140 << " uint candidateFound;\n"
141 << "} result;\n"
142 << "\n"
143 << "void main()\n"
144 << "{\n"
145 << " uint candidateFoundVal = 0u;\n"
146 << " rayQueryEXT rq;\n"
147 << " rayQueryInitializeEXT(rq, topLevelAS, args.rayFlags, args.cullMask, args.origin.xyz, args.Tmin, "
148 "args.direction.xyz, args.Tmax);\n"
149 << " while (rayQueryProceedEXT(rq)) {\n"
150 << " const uint candidateType = rayQueryGetIntersectionTypeEXT(rq, false);\n"
151 << " if (candidateType == gl_RayQueryCandidateIntersectionTriangleEXT) {\n"
152 << " candidateFoundVal = 1u;\n"
153 << " }\n"
154 << " else if (candidateType == gl_RayQueryCandidateIntersectionAABBEXT) {\n"
155 << " candidateFoundVal = 2u;\n"
156 << " break;\n"
157 << " }\n"
158 << " else {\n"
159 << " candidateFoundVal = 3u;\n"
160 << " break;\n"
161 << " }\n"
162 << " }\n"
163 << " result.candidateFound = candidateFoundVal;\n"
164 << "}\n";
165
166 programCollection.glslSources.add("comp") << glu::ComputeSource(comp.str()) << buildOptions;
167 }
168
createInstance(Context & context) const169 TestInstance *NonUniformArgsCase::createInstance(Context &context) const
170 {
171 return new NonUniformArgsInstance(context, m_params);
172 }
173
NonUniformArgsInstance(Context & context,const NonUniformParams & params)174 NonUniformArgsInstance::NonUniformArgsInstance(Context &context, const NonUniformParams ¶ms)
175 : TestInstance(context)
176 , m_params(params)
177 {
178 }
179
iterate(void)180 tcu::TestStatus NonUniformArgsInstance::iterate(void)
181 {
182 const auto &vkd = m_context.getDeviceInterface();
183 const auto device = m_context.getDevice();
184 auto &alloc = m_context.getDefaultAllocator();
185 const auto qIndex = m_context.getUniversalQueueFamilyIndex();
186 const auto queue = m_context.getUniversalQueue();
187 const auto stages = VK_SHADER_STAGE_COMPUTE_BIT;
188
189 // Geometry data constants.
190 const std::vector<tcu::Vec3> kOffscreenTriangle = {
191 // Triangle around (x=0, y=2) z=-5
192 tcu::Vec3(0.0f, 2.5f, -5.0f),
193 tcu::Vec3(-0.5f, 1.5f, -5.0f),
194 tcu::Vec3(0.5f, 1.5f, -5.0f),
195 };
196 const std::vector<tcu::Vec3> kOnscreenTriangle = {
197 // Triangle around (x=0, y=2) z=5
198 tcu::Vec3(0.0f, 2.5f, 5.0f),
199 tcu::Vec3(-0.5f, 1.5f, 5.0f),
200 tcu::Vec3(0.5f, 1.5f, 5.0f),
201 };
202 const tcu::Vec4 kGoodOrigin(0.0f, 2.0f, 0.0f, 0.0f); // Around (x=0, y=2) z=0.
203 const tcu::Vec4 kBadOrigin(0.0f, 8.0f, 0.0f, 0.0f); // Too high, around (x=0, y=8) depth 0.
204 const tcu::Vec4 kGoodDirection(0.0f, 0.0f, 1.0f, 0.0f); // Towards +z.
205 const tcu::Vec4 kBadDirection(1.0f, 0.0f, 0.0f, 0.0f); // Towards +x.
206 const float kGoodTmin = 4.0f; // Good to travel from z=0 to z=5.
207 const float kGoodTmax = 6.0f; // Ditto.
208 const float kBadTmin = 5.5f; // Tmin after triangle.
209 const float kBadTmax = 4.5f; // Tmax before triangle.
210 const uint32_t kGoodFlags = 0u; // MaskNone
211 const uint32_t kBadFlags = 256u; // SkipTrianglesKHR
212 const uint32_t kGoodCullMask = 0x0Fu; // Matches instance.
213 const uint32_t kBadCullMask = 0xF0u; // Does not match instance.
214
215 // Command pool and buffer.
216 const auto cmdPool = makeCommandPool(vkd, device, qIndex);
217 const auto cmdBufferPtr = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
218 const auto cmdBuffer = cmdBufferPtr.get();
219
220 beginCommandBuffer(vkd, cmdBuffer);
221
222 // Build acceleration structures.
223 auto topLevelAS = makeTopLevelAccelerationStructure();
224 auto bottomLevelAS = makeBottomLevelAccelerationStructure();
225
226 // Putting the offscreen triangle first makes sure hits have a geometryIndex=1, meaning sbtRecordStride matters.
227 std::vector<const std::vector<tcu::Vec3> *> geometries;
228 geometries.push_back(&kOffscreenTriangle);
229 geometries.push_back(&kOnscreenTriangle);
230
231 for (const auto &geometryPtr : geometries)
232 bottomLevelAS->addGeometry(*geometryPtr, true /* is triangles */);
233
234 bottomLevelAS->createAndBuild(vkd, device, cmdBuffer, alloc);
235
236 de::SharedPtr<BottomLevelAccelerationStructure> blasSharedPtr(bottomLevelAS.release());
237 topLevelAS->setInstanceCount(1);
238 topLevelAS->addInstance(blasSharedPtr, identityMatrix3x4, 0u, kGoodCullMask, 0u,
239 VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR);
240 topLevelAS->createAndBuild(vkd, device, cmdBuffer, alloc);
241
242 // Input storage buffer.
243 const auto inputBufferSize = static_cast<VkDeviceSize>(sizeof(ArgsBufferData));
244 const auto inputBufferInfo = makeBufferCreateInfo(inputBufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
245 BufferWithMemory inputBuffer(vkd, device, alloc, inputBufferInfo, MemoryRequirement::HostVisible);
246 auto &inputBufferAlloc = inputBuffer.getAllocation();
247
248 // Output storage buffer.
249 const auto outputBufferSize = static_cast<VkDeviceSize>(sizeof(uint32_t));
250 const auto outputBufferInfo = makeBufferCreateInfo(outputBufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
251 BufferWithMemory outputBuffer(vkd, device, alloc, outputBufferInfo, MemoryRequirement::HostVisible);
252 auto &outputBufferAlloc = outputBuffer.getAllocation();
253
254 // Fill output buffer with an initial invalid value.
255 deMemset(outputBufferAlloc.getHostPtr(), 42, static_cast<size_t>(outputBufferSize));
256 flushAlloc(vkd, device, outputBufferAlloc);
257
258 // Descriptor set layout and pipeline layout.
259 DescriptorSetLayoutBuilder setLayoutBuilder;
260 setLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, stages);
261 setLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, stages);
262 setLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, stages);
263 const auto setLayout = setLayoutBuilder.build(vkd, device);
264 const auto pipelineLayout = makePipelineLayout(vkd, device, setLayout.get());
265
266 // Descriptor pool and set.
267 DescriptorPoolBuilder poolBuilder;
268 poolBuilder.addType(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR);
269 poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2u);
270 const auto descriptorPool = poolBuilder.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
271 const auto descriptorSet = makeDescriptorSet(vkd, device, descriptorPool.get(), setLayout.get());
272
273 // Update descriptor set.
274 {
275 const VkWriteDescriptorSetAccelerationStructureKHR accelDescInfo = {
276 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
277 nullptr,
278 1u,
279 topLevelAS.get()->getPtr(),
280 };
281
282 const auto inputBufferDescInfo = makeDescriptorBufferInfo(inputBuffer.get(), 0ull, VK_WHOLE_SIZE);
283 const auto outputBufferDescInfo = makeDescriptorBufferInfo(outputBuffer.get(), 0ull, VK_WHOLE_SIZE);
284
285 DescriptorSetUpdateBuilder updateBuilder;
286 updateBuilder.writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(0u),
287 VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &accelDescInfo);
288 updateBuilder.writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(1u),
289 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &inputBufferDescInfo);
290 updateBuilder.writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(2u),
291 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &outputBufferDescInfo);
292 updateBuilder.update(vkd, device);
293 }
294
295 // Shader modules.
296 const auto compModule = createShaderModule(vkd, device, m_context.getBinaryCollection().get("comp"), 0u);
297
298 // Generate ids for the closest hit and miss shaders according to the test parameters.
299 DE_ASSERT(geometries.size() > 0u);
300
301 const VkPipelineShaderStageCreateInfo stageCreateInfo = {
302 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
303 nullptr, // const void* pNext;
304 0u, // VkPipelineShaderStageCreateFlags flags;
305 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
306 compModule.get(), // VkShaderModule module;
307 "main", // const char* pName;
308 nullptr, // const VkSpecializationInfo* pSpecializationInfo;
309 };
310
311 const VkComputePipelineCreateInfo pipelineCreateInfo = {
312 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
313 nullptr, // const void* pNext;
314 0u, // VkPipelineCreateFlags flags;
315 stageCreateInfo, // VkPipelineShaderStageCreateInfo stage;
316 pipelineLayout.get(), // VkPipelineLayout layout;
317 DE_NULL, // VkPipeline basePipelineHandle;
318 0, // int32_t basePipelineIndex;
319 };
320
321 const auto pipeline = createComputePipeline(vkd, device, DE_NULL, &pipelineCreateInfo);
322
323 // Fill input buffer values.
324 {
325 const ArgsBufferData argsBufferData = {
326 ((m_params.missCause == MissCause::ORIGIN) ? kBadOrigin : kGoodOrigin),
327 ((m_params.missCause == MissCause::DIRECTION) ? kBadDirection : kGoodDirection),
328 ((m_params.missCause == MissCause::TMIN) ? kBadTmin : kGoodTmin),
329 ((m_params.missCause == MissCause::TMAX) ? kBadTmax : kGoodTmax),
330 ((m_params.missCause == MissCause::FLAGS) ? kBadFlags : kGoodFlags),
331 ((m_params.missCause == MissCause::CULL_MASK) ? kBadCullMask : kGoodCullMask),
332 };
333
334 deMemcpy(inputBufferAlloc.getHostPtr(), &argsBufferData, sizeof(argsBufferData));
335 flushAlloc(vkd, device, inputBufferAlloc);
336 }
337
338 // Trace rays.
339 vkd.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline.get());
340 vkd.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout.get(), 0u, 1u,
341 &descriptorSet.get(), 0u, nullptr);
342 vkd.cmdDispatch(cmdBuffer, 1u, 1u, 1u);
343
344 // Barrier for the output buffer.
345 const auto bufferBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT);
346 vkd.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_HOST_BIT, 0u, 1u,
347 &bufferBarrier, 0u, nullptr, 0u, nullptr);
348
349 endCommandBuffer(vkd, cmdBuffer);
350 submitCommandsAndWait(vkd, device, queue, cmdBuffer);
351
352 // Check output value.
353 invalidateAlloc(vkd, device, outputBufferAlloc);
354 uint32_t outputVal = std::numeric_limits<uint32_t>::max();
355 deMemcpy(&outputVal, outputBufferAlloc.getHostPtr(), sizeof(outputVal));
356 const auto expectedVal = ((m_params.missCause == MissCause::NONE) ? 1u : 0u);
357
358 std::ostringstream msg;
359 msg << "Output value: " << outputVal << " (expected " << expectedVal << ")";
360
361 if (outputVal != expectedVal)
362 return tcu::TestStatus::fail(msg.str());
363
364 auto &log = m_context.getTestContext().getLog();
365 log << tcu::TestLog::Message << msg.str() << tcu::TestLog::EndMessage;
366
367 return tcu::TestStatus::pass("Pass");
368 }
369
370 } // namespace
371
createNonUniformArgsTests(tcu::TestContext & testCtx)372 tcu::TestCaseGroup *createNonUniformArgsTests(tcu::TestContext &testCtx)
373 {
374 // Test non-uniform arguments in traceRayExt()
375 de::MovePtr<tcu::TestCaseGroup> nonUniformGroup(new tcu::TestCaseGroup(testCtx, "non_uniform_args"));
376
377 NonUniformParams params;
378 for (int causeIdx = static_cast<int>(MissCause::NONE); causeIdx < static_cast<int>(MissCause::CAUSE_COUNT);
379 ++causeIdx)
380 {
381 params.missCause = static_cast<MissCause>(causeIdx);
382 const std::string testName =
383 ((params.missCause == MissCause::NONE) ? std::string("no_miss") : "miss_cause_" + de::toString(causeIdx));
384 nonUniformGroup->addChild(new NonUniformArgsCase(testCtx, testName, params));
385 }
386
387 return nonUniformGroup.release();
388 }
389
390 } // namespace RayQuery
391 } // namespace vkt
392