Merge "Fix error mask generation in checkLineContinuity" into nougat-cts-dev am:...
[platform/upstream/VK-GL-CTS.git] / external / vulkancts / modules / vulkan / sparse_resources / vktSparseResourcesImageMemoryAliasing.cpp
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  vktSparseResourcesImageMemoryAliasing.cpp
21  * \brief Sparse image memory aliasing tests
22  *//*--------------------------------------------------------------------*/
23
24 #include "vktSparseResourcesImageMemoryAliasing.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 #include "deSharedPtr.hpp"
43 #include "tcuTexture.hpp"
44
45 #include <deMath.h>
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         MODULO_DIVISOR = 128
61 };
62
63 const std::string getCoordStr  (const ImageType         imageType,
64                                                                 const std::string&      x,
65                                                                 const std::string&      y,
66                                                                 const std::string&      z)
67 {
68         switch (imageType)
69         {
70                 case IMAGE_TYPE_1D:
71                 case IMAGE_TYPE_BUFFER:
72                         return x;
73
74                 case IMAGE_TYPE_1D_ARRAY:
75                 case IMAGE_TYPE_2D:
76                         return "ivec2(" + x + "," + y + ")";
77
78                 case IMAGE_TYPE_2D_ARRAY:
79                 case IMAGE_TYPE_3D:
80                 case IMAGE_TYPE_CUBE:
81                 case IMAGE_TYPE_CUBE_ARRAY:
82                         return "ivec3(" + x + "," + y + "," + z + ")";
83
84                 default:
85                         DE_ASSERT(false);
86                         return "";
87         }
88 }
89
90 tcu::UVec3 alignedDivide (const VkExtent3D& extent, const VkExtent3D& divisor)
91 {
92         tcu::UVec3 result;
93
94         result.x() = extent.width  / divisor.width  + ((extent.width  % divisor.width)  ? 1u : 0u);
95         result.y() = extent.height / divisor.height + ((extent.height % divisor.height) ? 1u : 0u);
96         result.z() = extent.depth  / divisor.depth  + ((extent.depth  % divisor.depth)  ? 1u : 0u);
97
98         return result;
99 }
100
101 class ImageSparseMemoryAliasingCase : public TestCase
102 {
103 public:
104                                         ImageSparseMemoryAliasingCase   (tcu::TestContext&                      testCtx,
105                                                                                                          const std::string&                     name,
106                                                                                                          const std::string&                     description,
107                                                                                                          const ImageType                        imageType,
108                                                                                                          const tcu::UVec3&                      imageSize,
109                                                                                                          const tcu::TextureFormat&      format,
110                                                                                                          const glu::GLSLVersion         glslVersion);
111
112         void                    initPrograms                                    (SourceCollections&                     sourceCollections) const;
113         TestInstance*   createInstance                                  (Context&                                       context) const;
114
115
116 private:
117         const ImageType                         m_imageType;
118         const tcu::UVec3                        m_imageSize;
119         const tcu::TextureFormat        m_format;
120         const glu::GLSLVersion          m_glslVersion;
121 };
122
123 ImageSparseMemoryAliasingCase::ImageSparseMemoryAliasingCase (tcu::TestContext&                 testCtx,
124                                                                                                                           const std::string&            name,
125                                                                                                                           const std::string&            description,
126                                                                                                                           const ImageType                       imageType,
127                                                                                                                           const tcu::UVec3&                     imageSize,
128                                                                                                                           const tcu::TextureFormat&     format,
129                                                                                                                           const glu::GLSLVersion        glslVersion)
130         : TestCase                              (testCtx, name, description)
131         , m_imageType                   (imageType)
132         , m_imageSize                   (imageSize)
133         , m_format                              (format)
134         , m_glslVersion                 (glslVersion)
135 {
136 }
137
138 class ImageSparseMemoryAliasingInstance : public SparseResourcesBaseInstance
139 {
140 public:
141                                         ImageSparseMemoryAliasingInstance       (Context&                                                               context,
142                                                                                                                  const ImageType                                                imageType,
143                                                                                                                  const tcu::UVec3&                                              imageSize,
144                                                                                                                  const tcu::TextureFormat&                              format);
145
146         tcu::TestStatus iterate                                                         (void);
147
148 private:
149         const ImageType                         m_imageType;
150         const tcu::UVec3                        m_imageSize;
151         const tcu::TextureFormat        m_format;
152 };
153
154 ImageSparseMemoryAliasingInstance::ImageSparseMemoryAliasingInstance (Context&                                  context,
155                                                                                                                                           const ImageType                       imageType,
156                                                                                                                                           const tcu::UVec3&                     imageSize,
157                                                                                                                                           const tcu::TextureFormat&     format)
158         : SparseResourcesBaseInstance   (context)
159         , m_imageType                                   (imageType)
160         , m_imageSize                                   (imageSize)
161         , m_format                                              (format)
162 {
163 }
164
165 tcu::TestStatus ImageSparseMemoryAliasingInstance::iterate (void)
166 {
167         const InstanceInterface&                        instance                                = m_context.getInstanceInterface();
168         const VkPhysicalDevice                          physicalDevice                  = m_context.getPhysicalDevice();
169         const tcu::UVec3                                        maxWorkGroupSize                = tcu::UVec3(128u, 128u, 64u);
170         const tcu::UVec3                                        maxWorkGroupCount               = tcu::UVec3(65535u, 65535u, 65535u);
171         const deUint32                                          maxWorkGroupInvocations = 128u;
172         VkImageCreateInfo                                       imageSparseInfo;
173         VkSparseImageMemoryRequirements         aspectRequirements;
174         std::vector<DeviceMemorySp>                     deviceMemUniquePtrVec;
175
176         // Check if image size does not exceed device limits
177         if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
178                 TCU_THROW(NotSupportedError, "Image size not supported for device");
179
180         // Check if sparse memory aliasing is supported
181         if (!getPhysicalDeviceFeatures(instance, physicalDevice).sparseResidencyAliased)
182                 TCU_THROW(NotSupportedError, "Sparse memory aliasing not supported");
183
184         // Check if device supports sparse operations for image type
185         if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
186                 TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
187
188         imageSparseInfo.sType                                   = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
189         imageSparseInfo.pNext                                   = DE_NULL;
190         imageSparseInfo.flags                                   = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT |
191                                                                                           VK_IMAGE_CREATE_SPARSE_ALIASED_BIT   |
192                                                                                           VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
193         imageSparseInfo.imageType                               = mapImageType(m_imageType);
194         imageSparseInfo.format                                  = mapTextureFormat(m_format);
195         imageSparseInfo.extent                                  = makeExtent3D(getLayerSize(m_imageType, m_imageSize));
196         imageSparseInfo.arrayLayers                             = getNumLayers(m_imageType, m_imageSize);
197         imageSparseInfo.samples                                 = VK_SAMPLE_COUNT_1_BIT;
198         imageSparseInfo.tiling                                  = VK_IMAGE_TILING_OPTIMAL;
199         imageSparseInfo.initialLayout                   = VK_IMAGE_LAYOUT_UNDEFINED;
200         imageSparseInfo.usage                                   = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
201                                                                                           VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
202                                                                                           VK_IMAGE_USAGE_STORAGE_BIT;
203         imageSparseInfo.sharingMode                             = VK_SHARING_MODE_EXCLUSIVE;
204         imageSparseInfo.queueFamilyIndexCount   = 0u;
205         imageSparseInfo.pQueueFamilyIndices             = DE_NULL;
206
207         if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
208                 imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
209
210         {
211                 // Assign maximum allowed mipmap levels to image
212                 VkImageFormatProperties imageFormatProperties;
213                 instance.getPhysicalDeviceImageFormatProperties(physicalDevice,
214                         imageSparseInfo.format,
215                         imageSparseInfo.imageType,
216                         imageSparseInfo.tiling,
217                         imageSparseInfo.usage,
218                         imageSparseInfo.flags,
219                         &imageFormatProperties);
220
221                 imageSparseInfo.mipLevels = getImageMaxMipLevels(imageFormatProperties, imageSparseInfo.extent);
222         }
223
224         // Check if device supports sparse operations for image format
225         if (!checkSparseSupportForImageFormat(instance, physicalDevice, imageSparseInfo))
226                 TCU_THROW(NotSupportedError, "The image format does not support sparse operations");
227
228         {
229                 // Create logical device supporting both sparse and compute queues
230                 QueueRequirementsVec queueRequirements;
231                 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
232                 queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u));
233
234                 createDeviceSupportingQueues(queueRequirements);
235         }
236
237         const DeviceInterface&  deviceInterface = getDeviceInterface();
238         const Queue&                    sparseQueue             = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
239         const Queue&                    computeQueue    = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
240
241         // Create sparse image
242         const Unique<VkImage> imageRead(createImage(deviceInterface, getDevice(), &imageSparseInfo));
243         const Unique<VkImage> imageWrite(createImage(deviceInterface, getDevice(), &imageSparseInfo));
244
245         // Create semaphores to synchronize sparse binding operations with other operations on the sparse images
246         const Unique<VkSemaphore> memoryBindSemaphoreTransfer(createSemaphore(deviceInterface, getDevice()));
247         const Unique<VkSemaphore> memoryBindSemaphoreCompute(createSemaphore(deviceInterface, getDevice()));
248
249         const VkSemaphore imageMemoryBindSemaphores[] = { memoryBindSemaphoreTransfer.get(), memoryBindSemaphoreCompute.get() };
250
251         {
252                 std::vector<VkSparseImageMemoryBind> imageResidencyMemoryBinds;
253                 std::vector<VkSparseMemoryBind>          imageReadMipTailBinds;
254                 std::vector<VkSparseMemoryBind>          imageWriteMipTailBinds;
255
256                 // Get sparse image general memory requirements
257                 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageRead);
258
259                 // Check if required image memory size does not exceed device limits
260                 if (imageMemoryRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
261                         TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
262
263                 DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0);
264
265                 // Get sparse image sparse memory requirements
266                 const std::vector<VkSparseImageMemoryRequirements> sparseMemoryRequirements = getImageSparseMemoryRequirements(deviceInterface, getDevice(), *imageRead);
267
268                 DE_ASSERT(sparseMemoryRequirements.size() != 0);
269
270                 const deUint32 colorAspectIndex = getSparseAspectRequirementsIndex(sparseMemoryRequirements, VK_IMAGE_ASPECT_COLOR_BIT);
271
272                 if (colorAspectIndex == NO_MATCH_FOUND)
273                         TCU_THROW(NotSupportedError, "Not supported image aspect - the test supports currently only VK_IMAGE_ASPECT_COLOR_BIT");
274
275                 aspectRequirements = sparseMemoryRequirements[colorAspectIndex];
276
277                 const VkImageAspectFlags        aspectMask                      = aspectRequirements.formatProperties.aspectMask;
278                 const VkExtent3D                        imageGranularity        = aspectRequirements.formatProperties.imageGranularity;
279
280                 DE_ASSERT((aspectRequirements.imageMipTailSize % imageMemoryRequirements.alignment) == 0);
281
282                 const deUint32 memoryType = findMatchingMemoryType(instance, physicalDevice, imageMemoryRequirements, MemoryRequirement::Any);
283
284                 if (memoryType == NO_MATCH_FOUND)
285                         return tcu::TestStatus::fail("No matching memory type found");
286
287                 // Bind memory for each layer
288                 for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx)
289                 {
290                         for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
291                         {
292                                 const VkExtent3D                        mipExtent               = mipLevelExtents(imageSparseInfo.extent, mipLevelNdx);
293                                 const tcu::UVec3                        sparseBlocks    = alignedDivide(mipExtent, imageGranularity);
294                                 const deUint32                          numSparseBlocks = sparseBlocks.x() * sparseBlocks.y() * sparseBlocks.z();
295                                 const VkImageSubresource        subresource             = { aspectMask, mipLevelNdx, layerNdx };
296
297                                 const VkSparseImageMemoryBind imageMemoryBind = makeSparseImageMemoryBind(deviceInterface, getDevice(),
298                                         imageMemoryRequirements.alignment * numSparseBlocks, memoryType, subresource, makeOffset3D(0u, 0u, 0u), mipExtent);
299
300                                 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
301
302                                 imageResidencyMemoryBinds.push_back(imageMemoryBind);
303                         }
304
305                         if (!(aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
306                         {
307                                 const VkSparseMemoryBind imageReadMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
308                                         aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride);
309
310                                 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageReadMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
311
312                                 imageReadMipTailBinds.push_back(imageReadMipTailMemoryBind);
313
314                                 const VkSparseMemoryBind imageWriteMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
315                                         aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride);
316
317                                 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageWriteMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
318
319                                 imageWriteMipTailBinds.push_back(imageWriteMipTailMemoryBind);
320                         }
321                 }
322
323                 if ((aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
324                 {
325                         const VkSparseMemoryBind imageReadMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
326                                 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset);
327
328                         deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageReadMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
329
330                         imageReadMipTailBinds.push_back(imageReadMipTailMemoryBind);
331
332                         const VkSparseMemoryBind imageWriteMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
333                                 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset);
334
335                         deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageWriteMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
336
337                         imageWriteMipTailBinds.push_back(imageWriteMipTailMemoryBind);
338                 }
339
340                 VkBindSparseInfo bindSparseInfo =
341                 {
342                         VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,             //VkStructureType                                                       sType;
343                         DE_NULL,                                                                //const void*                                                           pNext;
344                         0u,                                                                             //deUint32                                                                      waitSemaphoreCount;
345                         DE_NULL,                                                                //const VkSemaphore*                                            pWaitSemaphores;
346                         0u,                                                                             //deUint32                                                                      bufferBindCount;
347                         DE_NULL,                                                                //const VkSparseBufferMemoryBindInfo*           pBufferBinds;
348                         0u,                                                                             //deUint32                                                                      imageOpaqueBindCount;
349                         DE_NULL,                                                                //const VkSparseImageOpaqueMemoryBindInfo*      pImageOpaqueBinds;
350                         0u,                                                                             //deUint32                                                                      imageBindCount;
351                         DE_NULL,                                                                //const VkSparseImageMemoryBindInfo*            pImageBinds;
352                         2u,                                                                             //deUint32                                                                      signalSemaphoreCount;
353                         imageMemoryBindSemaphores                               //const VkSemaphore*                                            pSignalSemaphores;
354                 };
355
356                 VkSparseImageMemoryBindInfo               imageResidencyBindInfo[2];
357                 VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo[2];
358
359                 if (imageResidencyMemoryBinds.size() > 0)
360                 {
361                         imageResidencyBindInfo[0].image         = *imageRead;
362                         imageResidencyBindInfo[0].bindCount = static_cast<deUint32>(imageResidencyMemoryBinds.size());
363                         imageResidencyBindInfo[0].pBinds        = &imageResidencyMemoryBinds[0];
364
365                         imageResidencyBindInfo[1].image         = *imageWrite;
366                         imageResidencyBindInfo[1].bindCount = static_cast<deUint32>(imageResidencyMemoryBinds.size());
367                         imageResidencyBindInfo[1].pBinds        = &imageResidencyMemoryBinds[0];
368
369                         bindSparseInfo.imageBindCount           = 2u;
370                         bindSparseInfo.pImageBinds                      = imageResidencyBindInfo;
371                 }
372
373                 if (imageReadMipTailBinds.size() > 0)
374                 {
375                         imageMipTailBindInfo[0].image           = *imageRead;
376                         imageMipTailBindInfo[0].bindCount       = static_cast<deUint32>(imageReadMipTailBinds.size());
377                         imageMipTailBindInfo[0].pBinds          = &imageReadMipTailBinds[0];
378
379                         imageMipTailBindInfo[1].image           = *imageWrite;
380                         imageMipTailBindInfo[1].bindCount       = static_cast<deUint32>(imageWriteMipTailBinds.size());
381                         imageMipTailBindInfo[1].pBinds          = &imageWriteMipTailBinds[0];
382
383                         bindSparseInfo.imageOpaqueBindCount = 2u;
384                         bindSparseInfo.pImageOpaqueBinds        = imageMipTailBindInfo;
385                 }
386
387                 // Submit sparse bind commands for execution
388                 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
389         }
390
391         // Create command buffer for compute and transfer oparations
392         const Unique<VkCommandPool>       commandPool  (makeCommandPool(deviceInterface, getDevice(), computeQueue.queueFamilyIndex));
393         const Unique<VkCommandBuffer> commandBuffer(allocateCommandBuffer(deviceInterface, getDevice(), *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
394
395         std::vector<VkBufferImageCopy> bufferImageCopy(imageSparseInfo.mipLevels);
396
397         {
398                 deUint32 bufferOffset = 0u;
399                 for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
400                 {
401                         bufferImageCopy[mipLevelNdx] = makeBufferImageCopy(mipLevelExtents(imageSparseInfo.extent, mipLevelNdx), imageSparseInfo.arrayLayers, mipLevelNdx, bufferOffset);
402                         bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
403                 }
404         }
405
406         // Start recording commands
407         beginCommandBuffer(deviceInterface, *commandBuffer);
408
409         const deUint32                                  imageSizeInBytes                = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
410         const VkBufferCreateInfo                inputBufferCreateInfo   = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
411         const Unique<VkBuffer>                  inputBuffer                             (createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo));
412         const de::UniquePtr<Allocation> inputBufferAlloc                (bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible));
413
414         std::vector<deUint8> referenceData(imageSizeInBytes);
415
416         for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
417         {
418                 const deUint32 mipLevelSizeInBytes      = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx);
419                 const deUint32 bufferOffset                     = static_cast<deUint32>(bufferImageCopy[mipLevelNdx].bufferOffset);
420
421                 deMemset(&referenceData[bufferOffset], mipLevelNdx + 1u, mipLevelSizeInBytes);
422         }
423
424         deMemcpy(inputBufferAlloc->getHostPtr(), &referenceData[0], imageSizeInBytes);
425
426         flushMappedMemoryRange(deviceInterface, getDevice(), inputBufferAlloc->getMemory(), inputBufferAlloc->getOffset(), imageSizeInBytes);
427
428         {
429                 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier
430                 (
431                         VK_ACCESS_HOST_WRITE_BIT,
432                         VK_ACCESS_TRANSFER_READ_BIT,
433                         *inputBuffer,
434                         0u,
435                         imageSizeInBytes
436                 );
437
438                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
439         }
440
441         {
442                 const VkImageMemoryBarrier imageSparseTransferDstBarrier = makeImageMemoryBarrier
443                 (
444                         0u,
445                         VK_ACCESS_TRANSFER_WRITE_BIT,
446                         VK_IMAGE_LAYOUT_UNDEFINED,
447                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
448                         sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex  : VK_QUEUE_FAMILY_IGNORED,
449                         sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? computeQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
450                         *imageRead,
451                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
452                 );
453
454                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferDstBarrier);
455         }
456
457         deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *imageRead, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
458
459         {
460                 const VkImageMemoryBarrier imageSparseTransferSrcBarrier = makeImageMemoryBarrier
461                 (
462                         VK_ACCESS_TRANSFER_WRITE_BIT,
463                         VK_ACCESS_TRANSFER_READ_BIT,
464                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
465                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
466                         *imageRead,
467                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
468                 );
469
470                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferSrcBarrier);
471         }
472
473         {
474                 const VkImageMemoryBarrier imageSparseShaderStorageBarrier = makeImageMemoryBarrier
475                 (
476                         0u,
477                         VK_ACCESS_SHADER_WRITE_BIT,
478                         VK_IMAGE_LAYOUT_UNDEFINED,
479                         VK_IMAGE_LAYOUT_GENERAL,
480                         *imageWrite,
481                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
482                 );
483
484                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseShaderStorageBarrier);
485         }
486
487         // Create descriptor set layout
488         const Unique<VkDescriptorSetLayout> descriptorSetLayout(
489                 DescriptorSetLayoutBuilder()
490                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
491                 .build(deviceInterface, getDevice()));
492
493         Unique<VkPipelineLayout> pipelineLayout(makePipelineLayout(deviceInterface, getDevice(), *descriptorSetLayout));
494
495         Unique<VkDescriptorPool> descriptorPool(
496                 DescriptorPoolBuilder()
497                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imageSparseInfo.mipLevels)
498                 .build(deviceInterface, getDevice(), VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, imageSparseInfo.mipLevels));
499
500         typedef de::SharedPtr< Unique<VkImageView> >            SharedVkImageView;
501         std::vector<SharedVkImageView>                                          imageViews;
502         imageViews.resize(imageSparseInfo.mipLevels);
503
504         typedef de::SharedPtr< Unique<VkDescriptorSet> >        SharedVkDescriptorSet;
505         std::vector<SharedVkDescriptorSet>                                      descriptorSets;
506         descriptorSets.resize(imageSparseInfo.mipLevels);
507
508         typedef de::SharedPtr< Unique<VkPipeline> >                     SharedVkPipeline;
509         std::vector<SharedVkPipeline>                                           computePipelines;
510         computePipelines.resize(imageSparseInfo.mipLevels);
511
512         for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
513         {
514                 std::ostringstream name;
515                 name << "comp" << mipLevelNdx;
516
517                 // Create and bind compute pipeline
518                 Unique<VkShaderModule> shaderModule(createShaderModule(deviceInterface, getDevice(), m_context.getBinaryCollection().get(name.str()), DE_NULL));
519
520                 computePipelines[mipLevelNdx]   = makeVkSharedPtr(makeComputePipeline(deviceInterface, getDevice(), *pipelineLayout, *shaderModule));
521                 VkPipeline computePipeline              = **computePipelines[mipLevelNdx];
522
523                 deviceInterface.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipeline);
524
525                 // Create and bind descriptor set
526                 descriptorSets[mipLevelNdx]             = makeVkSharedPtr(makeDescriptorSet(deviceInterface, getDevice(), *descriptorPool, *descriptorSetLayout));
527                 VkDescriptorSet descriptorSet   = **descriptorSets[mipLevelNdx];
528
529                 // Select which mipmap level to bind
530                 const VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, mipLevelNdx, 1u, 0u, imageSparseInfo.arrayLayers);
531
532                 imageViews[mipLevelNdx] = makeVkSharedPtr(makeImageView(deviceInterface, getDevice(), *imageWrite, mapImageViewType(m_imageType), imageSparseInfo.format, subresourceRange));
533                 VkImageView imageView   = **imageViews[mipLevelNdx];
534
535                 const VkDescriptorImageInfo sparseImageInfo = makeDescriptorImageInfo(DE_NULL, imageView, VK_IMAGE_LAYOUT_GENERAL);
536
537                 DescriptorSetUpdateBuilder()
538                         .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &sparseImageInfo)
539                         .update(deviceInterface, getDevice());
540
541                 deviceInterface.cmdBindDescriptorSets(*commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
542
543                 const tcu::UVec3        gridSize                        = getShaderGridSize(m_imageType, m_imageSize, mipLevelNdx);
544                 const deUint32          xWorkGroupSize          = std::min(std::min(gridSize.x(), maxWorkGroupSize.x()), maxWorkGroupInvocations);
545                 const deUint32          yWorkGroupSize          = std::min(std::min(gridSize.y(), maxWorkGroupSize.y()), maxWorkGroupInvocations / xWorkGroupSize);
546                 const deUint32          zWorkGroupSize          = std::min(std::min(gridSize.z(), maxWorkGroupSize.z()), maxWorkGroupInvocations / (xWorkGroupSize * yWorkGroupSize));
547
548                 const deUint32          xWorkGroupCount         = gridSize.x() / xWorkGroupSize + (gridSize.x() % xWorkGroupSize ? 1u : 0u);
549                 const deUint32          yWorkGroupCount         = gridSize.y() / yWorkGroupSize + (gridSize.y() % yWorkGroupSize ? 1u : 0u);
550                 const deUint32          zWorkGroupCount         = gridSize.z() / zWorkGroupSize + (gridSize.z() % zWorkGroupSize ? 1u : 0u);
551
552                 if (maxWorkGroupCount.x() < xWorkGroupCount ||
553                         maxWorkGroupCount.y() < yWorkGroupCount ||
554                         maxWorkGroupCount.z() < zWorkGroupCount)
555                         TCU_THROW(NotSupportedError, "Image size is not supported");
556
557                 deviceInterface.cmdDispatch(*commandBuffer, xWorkGroupCount, yWorkGroupCount, zWorkGroupCount);
558         }
559
560         {
561                 const VkMemoryBarrier memoryBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);
562
563                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 1u, &memoryBarrier, 0u, DE_NULL, 0u, DE_NULL);
564         }
565
566         const VkBufferCreateInfo                outputBufferCreateInfo  = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
567         const Unique<VkBuffer>                  outputBuffer                    (createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo));
568         const de::UniquePtr<Allocation> outputBufferAlloc               (bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible));
569
570         deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageRead, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
571
572         {
573                 const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier
574                 (
575                         VK_ACCESS_TRANSFER_WRITE_BIT,
576                         VK_ACCESS_HOST_READ_BIT,
577                         *outputBuffer,
578                         0u,
579                         imageSizeInBytes
580                 );
581
582                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &outputBufferBarrier, 0u, DE_NULL);
583         }
584
585         // End recording commands
586         endCommandBuffer(deviceInterface, *commandBuffer);
587
588         const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT };
589
590         // Submit commands for execution and wait for completion
591         submitCommandsAndWait(deviceInterface, getDevice(), computeQueue.queueHandle, *commandBuffer, 2u, imageMemoryBindSemaphores, stageBits);
592
593         // Retrieve data from buffer to host memory
594         invalidateMappedMemoryRange(deviceInterface, getDevice(), outputBufferAlloc->getMemory(), outputBufferAlloc->getOffset(), imageSizeInBytes);
595
596         const deUint8* outputData = static_cast<const deUint8*>(outputBufferAlloc->getHostPtr());
597
598         // Wait for sparse queue to become idle
599         deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
600
601         for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
602         {
603                 const tcu::UVec3                                  gridSize              = getShaderGridSize(m_imageType, m_imageSize, mipLevelNdx);
604                 const deUint32                                    bufferOffset  = static_cast<deUint32>(bufferImageCopy[mipLevelNdx].bufferOffset);
605                 const tcu::ConstPixelBufferAccess pixelBuffer   = tcu::ConstPixelBufferAccess(m_format, gridSize.x(), gridSize.y(), gridSize.z(), outputData + bufferOffset);
606
607                 for (deUint32 offsetZ = 0u; offsetZ < gridSize.z(); ++offsetZ)
608                 for (deUint32 offsetY = 0u; offsetY < gridSize.y(); ++offsetY)
609                 for (deUint32 offsetX = 0u; offsetX < gridSize.x(); ++offsetX)
610                 {
611                         const deUint32 index                    = offsetX + (offsetY + offsetZ * gridSize.y()) * gridSize.x();
612                         const tcu::UVec4 referenceValue = tcu::UVec4(index % MODULO_DIVISOR, index % MODULO_DIVISOR, index % MODULO_DIVISOR, 1u);
613                         const tcu::UVec4 outputValue    = pixelBuffer.getPixelUint(offsetX, offsetY, offsetZ);
614
615                         if (deMemCmp(&outputValue, &referenceValue, sizeof(deUint32) * getNumUsedChannels(m_format.order)) != 0)
616                                 return tcu::TestStatus::fail("Failed");
617                 }
618         }
619
620         for (deUint32 mipLevelNdx = aspectRequirements.imageMipTailFirstLod; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
621         {
622                 const deUint32 mipLevelSizeInBytes      = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx);
623                 const deUint32 bufferOffset                     = static_cast<deUint32>(bufferImageCopy[mipLevelNdx].bufferOffset);
624
625                 if (deMemCmp(outputData + bufferOffset, &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
626                         return tcu::TestStatus::fail("Failed");
627         }
628
629         return tcu::TestStatus::pass("Passed");
630 }
631
632 void ImageSparseMemoryAliasingCase::initPrograms(SourceCollections&     sourceCollections) const
633 {
634         const char* const       versionDecl                             = glu::getGLSLVersionDeclaration(m_glslVersion);
635         const std::string       imageTypeStr                    = getShaderImageType(m_format, m_imageType);
636         const std::string       formatQualifierStr              = getShaderImageFormatQualifier(m_format);
637         const std::string       formatDataStr                   = getShaderImageDataType(m_format);
638         const deUint32          maxWorkGroupInvocations = 128u;
639         const tcu::UVec3        maxWorkGroupSize                = tcu::UVec3(128u, 128u, 64u);
640
641         const tcu::UVec3        layerSize                               = getLayerSize(m_imageType, m_imageSize);
642         const deUint32          widestEdge                              = std::max(std::max(layerSize.x(), layerSize.y()), layerSize.z());
643         const deUint32          mipLevels                               = static_cast<deUint32>(deFloatLog2(static_cast<float>(widestEdge))) + 1u;
644
645         for (deUint32 mipLevelNdx = 0; mipLevelNdx < mipLevels; ++mipLevelNdx)
646         {
647                 // Create compute program
648                 const tcu::UVec3        gridSize                = getShaderGridSize(m_imageType, m_imageSize, mipLevelNdx);
649                 const deUint32          xWorkGroupSize  = std::min(std::min(gridSize.x(), maxWorkGroupSize.x()), maxWorkGroupInvocations);
650                 const deUint32          yWorkGroupSize  = std::min(std::min(gridSize.y(), maxWorkGroupSize.y()), maxWorkGroupInvocations / xWorkGroupSize);
651                 const deUint32          zWorkGroupSize  = std::min(std::min(gridSize.z(), maxWorkGroupSize.z()), maxWorkGroupInvocations / (xWorkGroupSize * yWorkGroupSize));
652
653                 std::ostringstream src;
654
655                 src << versionDecl << "\n"
656                         << "layout (local_size_x = " << xWorkGroupSize << ", local_size_y = " << yWorkGroupSize << ", local_size_z = " << zWorkGroupSize << ") in; \n"
657                         << "layout (binding = 0, " << formatQualifierStr << ") writeonly uniform highp " << imageTypeStr << " u_image;\n"
658                         << "void main (void)\n"
659                         << "{\n"
660                         << "    if( gl_GlobalInvocationID.x < " << gridSize.x() << " ) \n"
661                         << "    if( gl_GlobalInvocationID.y < " << gridSize.y() << " ) \n"
662                         << "    if( gl_GlobalInvocationID.z < " << gridSize.z() << " ) \n"
663                         << "    {\n"
664                         << "            int index = int(gl_GlobalInvocationID.x + (gl_GlobalInvocationID.y + gl_GlobalInvocationID.z*" << gridSize.y() << ")*" << gridSize.x() << ");\n"
665                         << "            imageStore(u_image, " << getCoordStr(m_imageType, "gl_GlobalInvocationID.x", "gl_GlobalInvocationID.y", "gl_GlobalInvocationID.z") << ","
666                         << formatDataStr << "( index % " << MODULO_DIVISOR << ", index % " << MODULO_DIVISOR << ", index % " << MODULO_DIVISOR << ", 1 )); \n"
667                         << "    }\n"
668                         << "}\n";
669
670                 std::ostringstream name;
671                 name << "comp" << mipLevelNdx;
672                 sourceCollections.glslSources.add(name.str()) << glu::ComputeSource(src.str());
673         }
674 }
675
676 TestInstance* ImageSparseMemoryAliasingCase::createInstance (Context& context) const
677 {
678         return new ImageSparseMemoryAliasingInstance(context, m_imageType, m_imageSize, m_format);
679 }
680
681 } // anonymous ns
682
683 tcu::TestCaseGroup* createImageSparseMemoryAliasingTests (tcu::TestContext& testCtx)
684 {
685         de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "image_sparse_memory_aliasing", "Sparse Image Memory Aliasing"));
686
687         static const deUint32 sizeCountPerImageType = 4u;
688
689         struct ImageParameters
690         {
691                 ImageType       imageType;
692                 tcu::UVec3      imageSizes[sizeCountPerImageType];
693         };
694
695         static const ImageParameters imageParametersArray[] =
696         {
697                 { IMAGE_TYPE_2D,                { tcu::UVec3(512u, 256u, 1u),   tcu::UVec3(128u, 128u, 1u),     tcu::UVec3(503u, 137u, 1u),     tcu::UVec3(11u, 37u, 1u) } },
698                 { IMAGE_TYPE_2D_ARRAY,  { tcu::UVec3(512u, 256u, 6u),   tcu::UVec3(128u, 128u, 8u),     tcu::UVec3(503u, 137u, 3u),     tcu::UVec3(11u, 37u, 3u) } },
699                 { IMAGE_TYPE_CUBE,              { tcu::UVec3(256u, 256u, 1u),   tcu::UVec3(128u, 128u, 1u),     tcu::UVec3(137u, 137u, 1u),     tcu::UVec3(11u, 11u, 1u) } },
700                 { IMAGE_TYPE_CUBE_ARRAY,{ tcu::UVec3(256u, 256u, 6u),   tcu::UVec3(128u, 128u, 8u),     tcu::UVec3(137u, 137u, 3u),     tcu::UVec3(11u, 11u, 3u) } },
701                 { IMAGE_TYPE_3D,                { tcu::UVec3(256u, 256u, 16u),  tcu::UVec3(128u, 128u, 8u),     tcu::UVec3(503u, 137u, 3u),     tcu::UVec3(11u, 37u, 3u) } }
702         };
703
704         static const tcu::TextureFormat formats[] =
705         {
706                 tcu::TextureFormat(tcu::TextureFormat::R,        tcu::TextureFormat::SIGNED_INT32),
707                 tcu::TextureFormat(tcu::TextureFormat::R,        tcu::TextureFormat::SIGNED_INT16),
708                 tcu::TextureFormat(tcu::TextureFormat::R,        tcu::TextureFormat::SIGNED_INT8),
709                 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32),
710                 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16),
711                 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8)
712         };
713
714         for (deInt32 imageTypeNdx = 0; imageTypeNdx < DE_LENGTH_OF_ARRAY(imageParametersArray); ++imageTypeNdx)
715         {
716                 const ImageType                                 imageType = imageParametersArray[imageTypeNdx].imageType;
717                 de::MovePtr<tcu::TestCaseGroup> imageTypeGroup(new tcu::TestCaseGroup(testCtx, getImageTypeName(imageType).c_str(), ""));
718
719                 for (deInt32 formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
720                 {
721                         const tcu::TextureFormat&               format = formats[formatNdx];
722                         de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, getShaderImageFormatQualifier(format).c_str(), ""));
723
724                         for (deInt32 imageSizeNdx = 0; imageSizeNdx < DE_LENGTH_OF_ARRAY(imageParametersArray[imageTypeNdx].imageSizes); ++imageSizeNdx)
725                         {
726                                 const tcu::UVec3 imageSize = imageParametersArray[imageTypeNdx].imageSizes[imageSizeNdx];
727
728                                 std::ostringstream stream;
729                                 stream << imageSize.x() << "_" << imageSize.y() << "_" << imageSize.z();
730
731                                 formatGroup->addChild(new ImageSparseMemoryAliasingCase(testCtx, stream.str(), "", imageType, imageSize, format, glu::GLSL_VERSION_440));
732                         }
733                         imageTypeGroup->addChild(formatGroup.release());
734                 }
735                 testGroup->addChild(imageTypeGroup.release());
736         }
737
738         return testGroup.release();
739 }
740
741 } // sparse
742 } // vkt