1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2016 The Khronos Group 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 vktSparseResourcesBufferMemoryAliasing.cpp
21 * \brief Sparse buffer memory aliasing tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktSparseResourcesBufferMemoryAliasing.hpp"
25 #include "vktSparseResourcesTestsUtil.hpp"
26 #include "vktSparseResourcesBase.hpp"
27 #include "vktTestCaseUtil.hpp"
28
29 #include "vkDefs.hpp"
30 #include "vkRef.hpp"
31 #include "vkRefUtil.hpp"
32 #include "vkPlatform.hpp"
33 #include "vkPrograms.hpp"
34 #include "vkRefUtil.hpp"
35 #include "vkMemUtil.hpp"
36 #include "vkQueryUtil.hpp"
37 #include "vkBuilderUtil.hpp"
38 #include "vkTypeUtil.hpp"
39
40 #include "deStringUtil.hpp"
41 #include "deUniquePtr.hpp"
42
43 #include <string>
44 #include <vector>
45
46 using namespace vk;
47
48 namespace vkt
49 {
50 namespace sparse
51 {
52 namespace
53 {
54
55 enum ShaderParameters
56 {
57 SIZE_OF_UINT_IN_SHADER = 4u,
58 MODULO_DIVISOR = 1024u
59 };
60
computeWorkGroupSize(const deUint32 numInvocations)61 tcu::UVec3 computeWorkGroupSize (const deUint32 numInvocations)
62 {
63 const deUint32 maxComputeWorkGroupInvocations = 128u;
64 const tcu::UVec3 maxComputeWorkGroupSize = tcu::UVec3(128u, 128u, 64u);
65 deUint32 numInvocationsLeft = numInvocations;
66
67 const deUint32 xWorkGroupSize = std::min(std::min(numInvocationsLeft, maxComputeWorkGroupSize.x()), maxComputeWorkGroupInvocations);
68 numInvocationsLeft = numInvocationsLeft / xWorkGroupSize + ((numInvocationsLeft % xWorkGroupSize) ? 1u : 0u);
69
70 const deUint32 yWorkGroupSize = std::min(std::min(numInvocationsLeft, maxComputeWorkGroupSize.y()), maxComputeWorkGroupInvocations / xWorkGroupSize);
71 numInvocationsLeft = numInvocationsLeft / yWorkGroupSize + ((numInvocationsLeft % yWorkGroupSize) ? 1u : 0u);
72
73 const deUint32 zWorkGroupSize = std::min(std::min(numInvocationsLeft, maxComputeWorkGroupSize.z()), maxComputeWorkGroupInvocations / (xWorkGroupSize*yWorkGroupSize));
74 numInvocationsLeft = numInvocationsLeft / zWorkGroupSize + ((numInvocationsLeft % zWorkGroupSize) ? 1u : 0u);
75
76 return tcu::UVec3(xWorkGroupSize, yWorkGroupSize, zWorkGroupSize);
77 }
78
79 class BufferSparseMemoryAliasingCase : public TestCase
80 {
81 public:
82 BufferSparseMemoryAliasingCase (tcu::TestContext& testCtx,
83 const std::string& name,
84 const std::string& description,
85 const deUint32 bufferSize,
86 const glu::GLSLVersion glslVersion);
87
88 void initPrograms (SourceCollections& sourceCollections) const;
89 TestInstance* createInstance (Context& context) const;
90
91 private:
92 const deUint32 m_bufferSizeInBytes;
93 const glu::GLSLVersion m_glslVersion;
94 };
95
BufferSparseMemoryAliasingCase(tcu::TestContext & testCtx,const std::string & name,const std::string & description,const deUint32 bufferSize,const glu::GLSLVersion glslVersion)96 BufferSparseMemoryAliasingCase::BufferSparseMemoryAliasingCase (tcu::TestContext& testCtx,
97 const std::string& name,
98 const std::string& description,
99 const deUint32 bufferSize,
100 const glu::GLSLVersion glslVersion)
101 : TestCase (testCtx, name, description)
102 , m_bufferSizeInBytes (bufferSize)
103 , m_glslVersion (glslVersion)
104 {
105 }
106
initPrograms(SourceCollections & sourceCollections) const107 void BufferSparseMemoryAliasingCase::initPrograms (SourceCollections& sourceCollections) const
108 {
109 // Create compute program
110 const char* const versionDecl = glu::getGLSLVersionDeclaration(m_glslVersion);
111 const deUint32 numInvocations = m_bufferSizeInBytes / SIZE_OF_UINT_IN_SHADER;
112 const tcu::UVec3 workGroupSize = computeWorkGroupSize(numInvocations);
113
114 std::ostringstream src;
115 src << versionDecl << "\n"
116 << "layout (local_size_x = " << workGroupSize.x() << ", local_size_y = " << workGroupSize.y() << ", local_size_z = " << workGroupSize.z() << ") in;\n"
117 << "layout(set = 0, binding = 0, std430) writeonly buffer Output\n"
118 << "{\n"
119 << " uint result[];\n"
120 << "} sb_out;\n"
121 << "\n"
122 << "void main (void)\n"
123 << "{\n"
124 << " uint index = gl_GlobalInvocationID.x + (gl_GlobalInvocationID.y + gl_GlobalInvocationID.z*gl_NumWorkGroups.y*gl_WorkGroupSize.y)*gl_NumWorkGroups.x*gl_WorkGroupSize.x;\n"
125 << " if ( index < " << m_bufferSizeInBytes / SIZE_OF_UINT_IN_SHADER << "u )\n"
126 << " {\n"
127 << " sb_out.result[index] = index % " << MODULO_DIVISOR << "u;\n"
128 << " }\n"
129 << "}\n";
130
131 sourceCollections.glslSources.add("comp") << glu::ComputeSource(src.str());
132 }
133
134 class BufferSparseMemoryAliasingInstance : public SparseResourcesBaseInstance
135 {
136 public:
137 BufferSparseMemoryAliasingInstance (Context& context,
138 const deUint32 bufferSize);
139
140 tcu::TestStatus iterate (void);
141
142 private:
143 const deUint32 m_bufferSizeInBytes;
144 };
145
BufferSparseMemoryAliasingInstance(Context & context,const deUint32 bufferSize)146 BufferSparseMemoryAliasingInstance::BufferSparseMemoryAliasingInstance (Context& context,
147 const deUint32 bufferSize)
148 : SparseResourcesBaseInstance (context)
149 , m_bufferSizeInBytes (bufferSize)
150 {
151 }
152
iterate(void)153 tcu::TestStatus BufferSparseMemoryAliasingInstance::iterate (void)
154 {
155 const InstanceInterface& instance = m_context.getInstanceInterface();
156 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
157
158 if (!getPhysicalDeviceFeatures(instance, physicalDevice).sparseBinding)
159 TCU_THROW(NotSupportedError, "Sparse binding not supported");
160
161 if (!getPhysicalDeviceFeatures(instance, physicalDevice).sparseResidencyAliased)
162 TCU_THROW(NotSupportedError, "Sparse memory aliasing not supported");
163
164 {
165 // Create logical device supporting both sparse and compute operations
166 QueueRequirementsVec queueRequirements;
167 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
168 queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u));
169
170 createDeviceSupportingQueues(queueRequirements);
171 }
172
173 const DeviceInterface& deviceInterface = getDeviceInterface();
174 const Queue& sparseQueue = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
175 const Queue& computeQueue = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
176
177 VkBufferCreateInfo bufferCreateInfo =
178 {
179 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
180 DE_NULL, // const void* pNext;
181 VK_BUFFER_CREATE_SPARSE_BINDING_BIT |
182 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, // VkBufferCreateFlags flags;
183 m_bufferSizeInBytes, // VkDeviceSize size;
184 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
185 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
186 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
187 0u, // deUint32 queueFamilyIndexCount;
188 DE_NULL // const deUint32* pQueueFamilyIndices;
189 };
190
191 const deUint32 queueFamilyIndices[] = { sparseQueue.queueFamilyIndex, computeQueue.queueFamilyIndex };
192
193 if (sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex)
194 {
195 bufferCreateInfo.sharingMode = VK_SHARING_MODE_CONCURRENT;
196 bufferCreateInfo.queueFamilyIndexCount = 2u;
197 bufferCreateInfo.pQueueFamilyIndices = queueFamilyIndices;
198 }
199
200 // Create sparse buffers
201 const Unique<VkBuffer> sparseBufferWrite(createBuffer(deviceInterface, getDevice(), &bufferCreateInfo));
202 const Unique<VkBuffer> sparseBufferRead (createBuffer(deviceInterface, getDevice(), &bufferCreateInfo));
203
204 // Create sparse buffers memory bind semaphore
205 const Unique<VkSemaphore> bufferMemoryBindSemaphore(makeSemaphore(deviceInterface, getDevice()));
206
207 const VkMemoryRequirements bufferMemRequirements = getBufferMemoryRequirements(deviceInterface, getDevice(), *sparseBufferWrite);
208
209 if (bufferMemRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
210 TCU_THROW(NotSupportedError, "Required memory size for sparse resources exceeds device limits");
211
212 DE_ASSERT((bufferMemRequirements.size % bufferMemRequirements.alignment) == 0);
213
214 const deUint32 memoryType = findMatchingMemoryType(instance, physicalDevice, bufferMemRequirements, MemoryRequirement::Any);
215
216 if (memoryType == NO_MATCH_FOUND)
217 return tcu::TestStatus::fail("No matching memory type found");
218
219 const VkSparseMemoryBind sparseMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(), bufferMemRequirements.size, memoryType, 0u);
220
221 Move<VkDeviceMemory> deviceMemoryPtr(check<VkDeviceMemory>(sparseMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL));
222
223 {
224 const VkSparseBufferMemoryBindInfo sparseBufferMemoryBindInfo[2] =
225 {
226 makeSparseBufferMemoryBindInfo
227 (*sparseBufferWrite, //VkBuffer buffer;
228 1u, //deUint32 bindCount;
229 &sparseMemoryBind //const VkSparseMemoryBind* Binds;
230 ),
231
232 makeSparseBufferMemoryBindInfo
233 (*sparseBufferRead, //VkBuffer buffer;
234 1u, //deUint32 bindCount;
235 &sparseMemoryBind //const VkSparseMemoryBind* Binds;
236 )
237 };
238
239 const VkBindSparseInfo bindSparseInfo =
240 {
241 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType;
242 DE_NULL, //const void* pNext;
243 0u, //deUint32 waitSemaphoreCount;
244 DE_NULL, //const VkSemaphore* pWaitSemaphores;
245 2u, //deUint32 bufferBindCount;
246 sparseBufferMemoryBindInfo, //const VkSparseBufferMemoryBindInfo* pBufferBinds;
247 0u, //deUint32 imageOpaqueBindCount;
248 DE_NULL, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
249 0u, //deUint32 imageBindCount;
250 DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds;
251 1u, //deUint32 signalSemaphoreCount;
252 &bufferMemoryBindSemaphore.get() //const VkSemaphore* pSignalSemaphores;
253 };
254
255 // Submit sparse bind commands for execution
256 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
257 }
258
259 // Create output buffer
260 const VkBufferCreateInfo outputBufferCreateInfo = makeBufferCreateInfo(m_bufferSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
261 const Unique<VkBuffer> outputBuffer (createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo));
262 const de::UniquePtr<Allocation> outputBufferAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible));
263
264 // Create command buffer for compute and data transfer oparations
265 const Unique<VkCommandPool> commandPool(makeCommandPool(deviceInterface, getDevice(), computeQueue.queueFamilyIndex));
266 const Unique<VkCommandBuffer> commandBuffer(makeCommandBuffer(deviceInterface, getDevice(), *commandPool));
267
268 // Start recording commands
269 beginCommandBuffer(deviceInterface, *commandBuffer);
270
271 // Create descriptor set
272 const Unique<VkDescriptorSetLayout> descriptorSetLayout(
273 DescriptorSetLayoutBuilder()
274 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT)
275 .build(deviceInterface, getDevice()));
276
277 // Create compute pipeline
278 const Unique<VkShaderModule> shaderModule(createShaderModule(deviceInterface, getDevice(), m_context.getBinaryCollection().get("comp"), DE_NULL));
279 const Unique<VkPipelineLayout> pipelineLayout(makePipelineLayout(deviceInterface, getDevice(), *descriptorSetLayout));
280 const Unique<VkPipeline> computePipeline(makeComputePipeline(deviceInterface, getDevice(), *pipelineLayout, *shaderModule));
281
282 deviceInterface.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *computePipeline);
283
284 // Create descriptor set
285 const Unique<VkDescriptorPool> descriptorPool(
286 DescriptorPoolBuilder()
287 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
288 .build(deviceInterface, getDevice(), VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
289
290 const Unique<VkDescriptorSet> descriptorSet(makeDescriptorSet(deviceInterface, getDevice(), *descriptorPool, *descriptorSetLayout));
291
292 {
293 const VkDescriptorBufferInfo sparseBufferInfo = makeDescriptorBufferInfo(*sparseBufferWrite, 0u, m_bufferSizeInBytes);
294
295 DescriptorSetUpdateBuilder()
296 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &sparseBufferInfo)
297 .update(deviceInterface, getDevice());
298 }
299
300 deviceInterface.cmdBindDescriptorSets(*commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
301
302 {
303 deUint32 numInvocationsLeft = m_bufferSizeInBytes / SIZE_OF_UINT_IN_SHADER;
304 const tcu::UVec3 workGroupSize = computeWorkGroupSize(numInvocationsLeft);
305 const tcu::UVec3 maxComputeWorkGroupCount = tcu::UVec3(65535u, 65535u, 65535u);
306
307 numInvocationsLeft -= workGroupSize.x()*workGroupSize.y()*workGroupSize.z();
308
309 const deUint32 xWorkGroupCount = std::min(numInvocationsLeft, maxComputeWorkGroupCount.x());
310 numInvocationsLeft = numInvocationsLeft / xWorkGroupCount + ((numInvocationsLeft % xWorkGroupCount) ? 1u : 0u);
311 const deUint32 yWorkGroupCount = std::min(numInvocationsLeft, maxComputeWorkGroupCount.y());
312 numInvocationsLeft = numInvocationsLeft / yWorkGroupCount + ((numInvocationsLeft % yWorkGroupCount) ? 1u : 0u);
313 const deUint32 zWorkGroupCount = std::min(numInvocationsLeft, maxComputeWorkGroupCount.z());
314 numInvocationsLeft = numInvocationsLeft / zWorkGroupCount + ((numInvocationsLeft % zWorkGroupCount) ? 1u : 0u);
315
316 if (numInvocationsLeft != 1u)
317 TCU_THROW(NotSupportedError, "Buffer size is not supported");
318
319 deviceInterface.cmdDispatch(*commandBuffer, xWorkGroupCount, yWorkGroupCount, zWorkGroupCount);
320 }
321
322 {
323 const VkBufferMemoryBarrier sparseBufferWriteBarrier
324 = makeBufferMemoryBarrier( VK_ACCESS_SHADER_WRITE_BIT,
325 VK_ACCESS_TRANSFER_READ_BIT,
326 *sparseBufferWrite,
327 0ull,
328 m_bufferSizeInBytes);
329
330 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &sparseBufferWriteBarrier, 0u, DE_NULL);
331 }
332
333 {
334 const VkBufferCopy bufferCopy = makeBufferCopy(0u, 0u, m_bufferSizeInBytes);
335
336 deviceInterface.cmdCopyBuffer(*commandBuffer, *sparseBufferRead, *outputBuffer, 1u, &bufferCopy);
337 }
338
339 {
340 const VkBufferMemoryBarrier outputBufferHostBarrier
341 = makeBufferMemoryBarrier( VK_ACCESS_TRANSFER_WRITE_BIT,
342 VK_ACCESS_HOST_READ_BIT,
343 *outputBuffer,
344 0ull,
345 m_bufferSizeInBytes);
346
347 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &outputBufferHostBarrier, 0u, DE_NULL);
348 }
349
350 // End recording commands
351 endCommandBuffer(deviceInterface, *commandBuffer);
352
353 // The stage at which execution is going to wait for finish of sparse binding operations
354 const VkPipelineStageFlags waitStageBits[] = { VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT };
355
356 // Submit commands for execution and wait for completion
357 submitCommandsAndWait(deviceInterface, getDevice(), computeQueue.queueHandle, *commandBuffer, 1u, &bufferMemoryBindSemaphore.get(), waitStageBits);
358
359 // Retrieve data from output buffer to host memory
360 invalidateMappedMemoryRange(deviceInterface, getDevice(), outputBufferAlloc->getMemory(), outputBufferAlloc->getOffset(), m_bufferSizeInBytes);
361
362 const deUint8* outputData = static_cast<const deUint8*>(outputBufferAlloc->getHostPtr());
363
364 // Wait for sparse queue to become idle
365 deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
366
367 // Prepare reference data
368 std::vector<deUint8> referenceData;
369 referenceData.resize(m_bufferSizeInBytes);
370
371 std::vector<deUint32> referenceDataBlock;
372 referenceDataBlock.resize(MODULO_DIVISOR);
373
374 for (deUint32 valueNdx = 0; valueNdx < MODULO_DIVISOR; ++valueNdx)
375 {
376 referenceDataBlock[valueNdx] = valueNdx % MODULO_DIVISOR;
377 }
378
379 const deUint32 fullBlockSizeInBytes = MODULO_DIVISOR * SIZE_OF_UINT_IN_SHADER;
380 const deUint32 lastBlockSizeInBytes = m_bufferSizeInBytes % fullBlockSizeInBytes;
381 const deUint32 numberOfBlocks = m_bufferSizeInBytes / fullBlockSizeInBytes + (lastBlockSizeInBytes ? 1u : 0u);
382
383 for (deUint32 blockNdx = 0; blockNdx < numberOfBlocks; ++blockNdx)
384 {
385 const deUint32 offset = blockNdx * fullBlockSizeInBytes;
386 deMemcpy(&referenceData[0] + offset, &referenceDataBlock[0], ((offset + fullBlockSizeInBytes) <= m_bufferSizeInBytes) ? fullBlockSizeInBytes : lastBlockSizeInBytes);
387 }
388
389 // Compare reference data with output data
390 if (deMemCmp(&referenceData[0], outputData, m_bufferSizeInBytes) != 0)
391 return tcu::TestStatus::fail("Failed");
392 else
393 return tcu::TestStatus::pass("Passed");
394 }
395
createInstance(Context & context) const396 TestInstance* BufferSparseMemoryAliasingCase::createInstance (Context& context) const
397 {
398 return new BufferSparseMemoryAliasingInstance(context, m_bufferSizeInBytes);
399 }
400
401 } // anonymous ns
402
addBufferSparseMemoryAliasingTests(tcu::TestCaseGroup * group)403 void addBufferSparseMemoryAliasingTests(tcu::TestCaseGroup* group)
404 {
405 group->addChild(new BufferSparseMemoryAliasingCase(group->getTestContext(), "buffer_size_2_10", "", 1 << 10, glu::GLSL_VERSION_440));
406 group->addChild(new BufferSparseMemoryAliasingCase(group->getTestContext(), "buffer_size_2_12", "", 1 << 12, glu::GLSL_VERSION_440));
407 group->addChild(new BufferSparseMemoryAliasingCase(group->getTestContext(), "buffer_size_2_16", "", 1 << 16, glu::GLSL_VERSION_440));
408 group->addChild(new BufferSparseMemoryAliasingCase(group->getTestContext(), "buffer_size_2_17", "", 1 << 17, glu::GLSL_VERSION_440));
409 group->addChild(new BufferSparseMemoryAliasingCase(group->getTestContext(), "buffer_size_2_20", "", 1 << 20, glu::GLSL_VERSION_440));
410 group->addChild(new BufferSparseMemoryAliasingCase(group->getTestContext(), "buffer_size_2_24", "", 1 << 24, glu::GLSL_VERSION_440));
411 }
412
413 } // sparse
414 } // vkt
415