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