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 vktSparseResourcesMipmapSparseResidency.cpp 21 * \brief Sparse partially resident images with mipmaps tests 22 *//*--------------------------------------------------------------------*/ 23 24#include "vktSparseResourcesMipmapSparseResidency.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 "vkMemUtil.hpp" 35#include "vkBarrierUtil.hpp" 36#include "vkBuilderUtil.hpp" 37#include "vkImageUtil.hpp" 38#include "vkQueryUtil.hpp" 39#include "vkTypeUtil.hpp" 40#include "vkCmdUtil.hpp" 41 42#include "deUniquePtr.hpp" 43#include "deStringUtil.hpp" 44#include "tcuTextureUtil.hpp" 45 46#include <string> 47#include <vector> 48 49using namespace vk; 50 51namespace vkt 52{ 53namespace sparse 54{ 55namespace 56{ 57 58class MipmapSparseResidencyCase : public TestCase 59{ 60public: 61 MipmapSparseResidencyCase (tcu::TestContext& testCtx, 62 const std::string& name, 63 const ImageType imageType, 64 const tcu::UVec3& imageSize, 65 const VkFormat format, 66 const bool useDeviceGroups); 67 68 TestInstance* createInstance (Context& context) const; 69 virtual void checkSupport (Context& context) const; 70 71private: 72 const bool m_useDeviceGroups; 73 const ImageType m_imageType; 74 const tcu::UVec3 m_imageSize; 75 const VkFormat m_format; 76}; 77 78MipmapSparseResidencyCase::MipmapSparseResidencyCase (tcu::TestContext& testCtx, 79 const std::string& name, 80 const ImageType imageType, 81 const tcu::UVec3& imageSize, 82 const VkFormat format, 83 const bool useDeviceGroups) 84 : TestCase (testCtx, name) 85 , m_useDeviceGroups (useDeviceGroups) 86 , m_imageType (imageType) 87 , m_imageSize (imageSize) 88 , m_format (format) 89{ 90} 91 92void MipmapSparseResidencyCase::checkSupport (Context& context) const 93{ 94 const InstanceInterface& instance = context.getInstanceInterface(); 95 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 96 97 // Check if image size does not exceed device limits 98 if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize)) 99 TCU_THROW(NotSupportedError, "Image size not supported for device"); 100 101 // Check if device supports sparse operations for image type 102 if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType)) 103 TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported"); 104 105 if (formatIsR64(m_format)) 106 { 107 context.requireDeviceFunctionality("VK_EXT_shader_image_atomic_int64"); 108 109 if (context.getShaderImageAtomicInt64FeaturesEXT().sparseImageInt64Atomics == VK_FALSE) 110 { 111 TCU_THROW(NotSupportedError, "sparseImageInt64Atomics is not supported for device"); 112 } 113 } 114} 115 116class MipmapSparseResidencyInstance : public SparseResourcesBaseInstance 117{ 118public: 119 MipmapSparseResidencyInstance (Context& context, 120 const ImageType imageType, 121 const tcu::UVec3& imageSize, 122 const VkFormat format, 123 const bool useDeviceGroups); 124 125 126 tcu::TestStatus iterate (void); 127 128private: 129 const bool m_useDeviceGroups; 130 const ImageType m_imageType; 131 const tcu::UVec3 m_imageSize; 132 const VkFormat m_format; 133}; 134 135MipmapSparseResidencyInstance::MipmapSparseResidencyInstance (Context& context, 136 const ImageType imageType, 137 const tcu::UVec3& imageSize, 138 const VkFormat format, 139 const bool useDeviceGroups) 140 : SparseResourcesBaseInstance (context, useDeviceGroups) 141 , m_useDeviceGroups (useDeviceGroups) 142 , m_imageType (imageType) 143 , m_imageSize (imageSize) 144 , m_format (format) 145{ 146} 147 148tcu::TestStatus MipmapSparseResidencyInstance::iterate (void) 149{ 150 const InstanceInterface& instance = m_context.getInstanceInterface(); 151 { 152 // Create logical device supporting both sparse and compute operations 153 QueueRequirementsVec queueRequirements; 154 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u)); 155 queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u)); 156 157 createDeviceSupportingQueues(queueRequirements); 158 } 159 160 const VkPhysicalDevice physicalDevice = getPhysicalDevice(); 161 VkImageCreateInfo imageSparseInfo; 162 std::vector<DeviceMemorySp> deviceMemUniquePtrVec; 163 164 const DeviceInterface& deviceInterface = getDeviceInterface(); 165 const Queue& sparseQueue = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0); 166 const Queue& computeQueue = getQueue(VK_QUEUE_COMPUTE_BIT, 0); 167 const PlanarFormatDescription formatDescription = getPlanarFormatDescription(m_format); 168 169 // Go through all physical devices 170 for (deUint32 physDevID = 0; physDevID < m_numPhysicalDevices; physDevID++) 171 { 172 const deUint32 firstDeviceID = physDevID; 173 const deUint32 secondDeviceID = (firstDeviceID + 1) % m_numPhysicalDevices; 174 175 imageSparseInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; 176 imageSparseInfo.pNext = DE_NULL; 177 imageSparseInfo.flags = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT; 178 imageSparseInfo.imageType = mapImageType(m_imageType); 179 imageSparseInfo.format = m_format; 180 imageSparseInfo.extent = makeExtent3D(getLayerSize(m_imageType, m_imageSize)); 181 imageSparseInfo.arrayLayers = getNumLayers(m_imageType, m_imageSize); 182 imageSparseInfo.samples = VK_SAMPLE_COUNT_1_BIT; 183 imageSparseInfo.tiling = VK_IMAGE_TILING_OPTIMAL; 184 imageSparseInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; 185 imageSparseInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | 186 VK_IMAGE_USAGE_TRANSFER_SRC_BIT; 187 imageSparseInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; 188 imageSparseInfo.queueFamilyIndexCount = 0u; 189 imageSparseInfo.pQueueFamilyIndices = DE_NULL; 190 191 if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY) 192 { 193 imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; 194 } 195 196 // Check if device supports sparse operations for image format 197 if (!checkSparseSupportForImageFormat(instance, physicalDevice, imageSparseInfo)) 198 TCU_THROW(NotSupportedError, "The image format does not support sparse operations"); 199 200 { 201 VkImageFormatProperties imageFormatProperties; 202 if (instance.getPhysicalDeviceImageFormatProperties(physicalDevice, 203 imageSparseInfo.format, 204 imageSparseInfo.imageType, 205 imageSparseInfo.tiling, 206 imageSparseInfo.usage, 207 imageSparseInfo.flags, 208 &imageFormatProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED) 209 { 210 TCU_THROW(NotSupportedError, "Image format does not support sparse operations"); 211 } 212 213 imageSparseInfo.mipLevels = getMipmapCount(m_format, formatDescription, imageFormatProperties, imageSparseInfo.extent); 214 } 215 216 // Create sparse image 217 const Unique<VkImage> imageSparse(createImage(deviceInterface, getDevice(), &imageSparseInfo)); 218 219 // Create sparse image memory bind semaphore 220 const Unique<VkSemaphore> imageMemoryBindSemaphore(createSemaphore(deviceInterface, getDevice())); 221 222 std::vector<VkSparseImageMemoryRequirements> sparseMemoryRequirements; 223 224 { 225 // Get sparse image general memory requirements 226 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse); 227 228 // Check if required image memory size does not exceed device limits 229 if (imageMemoryRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize) 230 TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits"); 231 232 DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0); 233 234 const deUint32 memoryType = findMatchingMemoryType(instance, getPhysicalDevice(secondDeviceID), imageMemoryRequirements, MemoryRequirement::Any); 235 236 if (memoryType == NO_MATCH_FOUND) 237 return tcu::TestStatus::fail("No matching memory type found"); 238 239 if (firstDeviceID != secondDeviceID) 240 { 241 VkPeerMemoryFeatureFlags peerMemoryFeatureFlags = (VkPeerMemoryFeatureFlags)0; 242 const deUint32 heapIndex = getHeapIndexForMemoryType(instance, getPhysicalDevice(secondDeviceID), memoryType); 243 deviceInterface.getDeviceGroupPeerMemoryFeatures(getDevice(), heapIndex, firstDeviceID, secondDeviceID, &peerMemoryFeatureFlags); 244 245 if (((peerMemoryFeatureFlags & VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT) == 0) || 246 ((peerMemoryFeatureFlags & VK_PEER_MEMORY_FEATURE_COPY_DST_BIT) == 0)) 247 { 248 TCU_THROW(NotSupportedError, "Peer memory does not support COPY_SRC and COPY_DST"); 249 } 250 } 251 252 // Get sparse image sparse memory requirements 253 sparseMemoryRequirements = getImageSparseMemoryRequirements(deviceInterface, getDevice(), *imageSparse); 254 DE_ASSERT(sparseMemoryRequirements.size() != 0); 255 256 const deUint32 metadataAspectIndex = getSparseAspectRequirementsIndex(sparseMemoryRequirements, VK_IMAGE_ASPECT_METADATA_BIT); 257 258 std::vector<VkSparseImageMemoryBind> imageResidencyMemoryBinds; 259 std::vector<VkSparseMemoryBind> imageMipTailMemoryBinds; 260 261 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx) 262 { 263 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT; 264 const deUint32 aspectIndex = getSparseAspectRequirementsIndex(sparseMemoryRequirements, aspect); 265 266 if (aspectIndex == NO_MATCH_FOUND) 267 TCU_THROW(NotSupportedError, "Not supported image aspect"); 268 269 VkSparseImageMemoryRequirements aspectRequirements = sparseMemoryRequirements[aspectIndex]; 270 271 DE_ASSERT((aspectRequirements.imageMipTailSize % imageMemoryRequirements.alignment) == 0); 272 273 VkExtent3D imageGranularity = aspectRequirements.formatProperties.imageGranularity; 274 275 // Bind memory for each layer 276 for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx) 277 { 278 for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx) 279 { 280 const VkExtent3D mipExtent = getPlaneExtent(formatDescription, imageSparseInfo.extent, planeNdx, mipLevelNdx); 281 const tcu::UVec3 sparseBlocks = alignedDivide(mipExtent, imageGranularity); 282 const deUint32 numSparseBlocks = sparseBlocks.x() * sparseBlocks.y() * sparseBlocks.z(); 283 const VkImageSubresource subresource = { aspect, mipLevelNdx, layerNdx }; 284 285 const VkSparseImageMemoryBind imageMemoryBind = makeSparseImageMemoryBind(deviceInterface, getDevice(), 286 imageMemoryRequirements.alignment * numSparseBlocks, memoryType, subresource, makeOffset3D(0u, 0u, 0u), mipExtent); 287 288 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL)))); 289 290 imageResidencyMemoryBinds.push_back(imageMemoryBind); 291 } 292 293 if (!(aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels) 294 { 295 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(), 296 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride); 297 298 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL)))); 299 300 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind); 301 } 302 303 // Metadata 304 if (metadataAspectIndex != NO_MATCH_FOUND) 305 { 306 const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseMemoryRequirements[metadataAspectIndex]; 307 308 if (!(metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT)) 309 { 310 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(), 311 metadataAspectRequirements.imageMipTailSize, memoryType, 312 metadataAspectRequirements.imageMipTailOffset + layerNdx * metadataAspectRequirements.imageMipTailStride, 313 VK_SPARSE_MEMORY_BIND_METADATA_BIT); 314 315 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL)))); 316 317 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind); 318 } 319 } 320 } 321 322 if ((aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels) 323 { 324 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(), 325 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset); 326 327 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL)))); 328 329 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind); 330 } 331 } 332 333 // Metadata 334 if (metadataAspectIndex != NO_MATCH_FOUND) 335 { 336 const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseMemoryRequirements[metadataAspectIndex]; 337 338 if (metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) 339 { 340 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(), 341 metadataAspectRequirements.imageMipTailSize, memoryType, metadataAspectRequirements.imageMipTailOffset, 342 VK_SPARSE_MEMORY_BIND_METADATA_BIT); 343 344 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL)))); 345 346 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind); 347 } 348 } 349 350 const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo = 351 { 352 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, //VkStructureType sType; 353 DE_NULL, //const void* pNext; 354 firstDeviceID, //deUint32 resourceDeviceIndex; 355 secondDeviceID, //deUint32 memoryDeviceIndex; 356 }; 357 358 VkBindSparseInfo bindSparseInfo = 359 { 360 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType; 361 m_useDeviceGroups ? &devGroupBindSparseInfo : DE_NULL, //const void* pNext; 362 0u, //deUint32 waitSemaphoreCount; 363 DE_NULL, //const VkSemaphore* pWaitSemaphores; 364 0u, //deUint32 bufferBindCount; 365 DE_NULL, //const VkSparseBufferMemoryBindInfo* pBufferBinds; 366 0u, //deUint32 imageOpaqueBindCount; 367 DE_NULL, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; 368 0u, //deUint32 imageBindCount; 369 DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds; 370 1u, //deUint32 signalSemaphoreCount; 371 &imageMemoryBindSemaphore.get() //const VkSemaphore* pSignalSemaphores; 372 }; 373 374 VkSparseImageMemoryBindInfo imageResidencyBindInfo; 375 VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo; 376 377 if (imageResidencyMemoryBinds.size() > 0) 378 { 379 imageResidencyBindInfo.image = *imageSparse; 380 imageResidencyBindInfo.bindCount = static_cast<deUint32>(imageResidencyMemoryBinds.size()); 381 imageResidencyBindInfo.pBinds = imageResidencyMemoryBinds.data(); 382 383 bindSparseInfo.imageBindCount = 1u; 384 bindSparseInfo.pImageBinds = &imageResidencyBindInfo; 385 } 386 387 if (imageMipTailMemoryBinds.size() > 0) 388 { 389 imageMipTailBindInfo.image = *imageSparse; 390 imageMipTailBindInfo.bindCount = static_cast<deUint32>(imageMipTailMemoryBinds.size()); 391 imageMipTailBindInfo.pBinds = imageMipTailMemoryBinds.data(); 392 393 bindSparseInfo.imageOpaqueBindCount = 1u; 394 bindSparseInfo.pImageOpaqueBinds = &imageMipTailBindInfo; 395 } 396 397 // Submit sparse bind commands for execution 398 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL)); 399 } 400 401 deUint32 imageSizeInBytes = 0; 402 403 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx) 404 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx) 405 imageSizeInBytes += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY); 406 407 std::vector <VkBufferImageCopy> bufferImageCopy(formatDescription.numPlanes*imageSparseInfo.mipLevels); 408 { 409 deUint32 bufferOffset = 0; 410 411 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx) 412 { 413 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT; 414 415 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx) 416 { 417 bufferImageCopy[planeNdx*imageSparseInfo.mipLevels + mipmapNdx] = 418 { 419 bufferOffset, // VkDeviceSize bufferOffset; 420 0u, // deUint32 bufferRowLength; 421 0u, // deUint32 bufferImageHeight; 422 makeImageSubresourceLayers(aspect, mipmapNdx, 0u, imageSparseInfo.arrayLayers), // VkImageSubresourceLayers imageSubresource; 423 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset; 424 vk::getPlaneExtent(formatDescription, imageSparseInfo.extent, planeNdx, mipmapNdx) // VkExtent3D imageExtent; 425 }; 426 bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY); 427 } 428 } 429 } 430 431 // Create command buffer for compute and transfer operations 432 const Unique<VkCommandPool> commandPool(makeCommandPool(deviceInterface, getDevice(), computeQueue.queueFamilyIndex)); 433 const Unique<VkCommandBuffer> commandBuffer(allocateCommandBuffer(deviceInterface, getDevice(), *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 434 435 // Start recording commands 436 beginCommandBuffer(deviceInterface, *commandBuffer); 437 438 const VkBufferCreateInfo inputBufferCreateInfo = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT); 439 const Unique<VkBuffer> inputBuffer (createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo)); 440 const de::UniquePtr<Allocation> inputBufferAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible)); 441 442 std::vector<deUint8> referenceData(imageSizeInBytes); 443 444 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse); 445 446 for (deUint32 valueNdx = 0; valueNdx < imageSizeInBytes; ++valueNdx) 447 { 448 referenceData[valueNdx] = static_cast<deUint8>((valueNdx % imageMemoryRequirements.alignment) + 1u); 449 } 450 451 { 452 deMemcpy(inputBufferAlloc->getHostPtr(), referenceData.data(), imageSizeInBytes); 453 flushAlloc(deviceInterface, getDevice(), *inputBufferAlloc); 454 455 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier 456 ( 457 VK_ACCESS_HOST_WRITE_BIT, 458 VK_ACCESS_TRANSFER_READ_BIT, 459 *inputBuffer, 460 0u, 461 imageSizeInBytes 462 ); 463 464 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL); 465 } 466 467 { 468 std::vector<VkImageMemoryBarrier> imageSparseTransferDstBarriers; 469 470 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx) 471 { 472 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT; 473 474 imageSparseTransferDstBarriers.emplace_back ( makeImageMemoryBarrier 475 ( 476 0u, 477 VK_ACCESS_TRANSFER_WRITE_BIT, 478 VK_IMAGE_LAYOUT_UNDEFINED, 479 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 480 *imageSparse, 481 makeImageSubresourceRange(aspect, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers), 482 sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED, 483 sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? computeQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED 484 )); 485 } 486 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, static_cast<deUint32>(imageSparseTransferDstBarriers.size()), imageSparseTransferDstBarriers.data()); 487 } 488 489 deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]); 490 491 { 492 std::vector<VkImageMemoryBarrier> imageSparseTransferSrcBarriers; 493 494 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx) 495 { 496 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT; 497 498 imageSparseTransferSrcBarriers.emplace_back(makeImageMemoryBarrier 499 ( 500 VK_ACCESS_TRANSFER_WRITE_BIT, 501 VK_ACCESS_TRANSFER_READ_BIT, 502 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 503 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 504 *imageSparse, 505 makeImageSubresourceRange(aspect, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers) 506 )); 507 } 508 509 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, static_cast<deUint32>(imageSparseTransferSrcBarriers.size()), imageSparseTransferSrcBarriers.data()); 510 } 511 512 const VkBufferCreateInfo outputBufferCreateInfo = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT); 513 const Unique<VkBuffer> outputBuffer (createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo)); 514 const de::UniquePtr<Allocation> outputBufferAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible)); 515 516 deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, static_cast<deUint32>(bufferImageCopy.size()), bufferImageCopy.data()); 517 518 { 519 const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier 520 ( 521 VK_ACCESS_TRANSFER_WRITE_BIT, 522 VK_ACCESS_HOST_READ_BIT, 523 *outputBuffer, 524 0u, 525 imageSizeInBytes 526 ); 527 528 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &outputBufferBarrier, 0u, DE_NULL); 529 } 530 531 // End recording commands 532 endCommandBuffer(deviceInterface, *commandBuffer); 533 534 const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT }; 535 536 // Submit commands for execution and wait for completion 537 submitCommandsAndWait(deviceInterface, getDevice(), computeQueue.queueHandle, *commandBuffer, 1u, &imageMemoryBindSemaphore.get(), stageBits, 538 0, DE_NULL, m_useDeviceGroups, firstDeviceID); 539 540 // Retrieve data from buffer to host memory 541 invalidateAlloc(deviceInterface, getDevice(), *outputBufferAlloc); 542 543 const deUint8* outputData = static_cast<const deUint8*>(outputBufferAlloc->getHostPtr()); 544 545 // Wait for sparse queue to become idle 546 deviceInterface.queueWaitIdle(sparseQueue.queueHandle); 547 548 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx) 549 { 550 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx) 551 { 552 const deUint32 mipLevelSizeInBytes = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx); 553 const deUint32 bufferOffset = static_cast<deUint32>(bufferImageCopy[planeNdx*imageSparseInfo.mipLevels + mipmapNdx].bufferOffset); 554 555 if (deMemCmp(outputData + bufferOffset, &referenceData[bufferOffset], mipLevelSizeInBytes) != 0) 556 return tcu::TestStatus::fail("Failed"); 557 } 558 } 559 } 560 return tcu::TestStatus::pass("Passed"); 561} 562 563TestInstance* MipmapSparseResidencyCase::createInstance (Context& context) const 564{ 565 return new MipmapSparseResidencyInstance(context, m_imageType, m_imageSize, m_format, m_useDeviceGroups); 566} 567 568} // anonymous ns 569 570tcu::TestCaseGroup* createMipmapSparseResidencyTestsCommon (tcu::TestContext& testCtx, de::MovePtr<tcu::TestCaseGroup> testGroup, const bool useDeviceGroup = false) 571{ 572 const std::vector<TestImageParameters> imageParameters 573 { 574 { IMAGE_TYPE_2D, { tcu::UVec3(512u, 256u, 1u), tcu::UVec3(1024u, 128u, 1u), tcu::UVec3(11u, 137u, 1u) }, getTestFormats(IMAGE_TYPE_2D) }, 575 { IMAGE_TYPE_2D_ARRAY, { tcu::UVec3(512u, 256u, 6u), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u, 137u, 3u) }, getTestFormats(IMAGE_TYPE_2D_ARRAY) }, 576 { IMAGE_TYPE_CUBE, { tcu::UVec3(256u, 256u, 1u), tcu::UVec3(128u, 128u, 1u), tcu::UVec3(137u, 137u, 1u) }, getTestFormats(IMAGE_TYPE_CUBE) }, 577 { IMAGE_TYPE_CUBE_ARRAY, { tcu::UVec3(256u, 256u, 6u), tcu::UVec3(128u, 128u, 8u), tcu::UVec3(137u, 137u, 3u) }, getTestFormats(IMAGE_TYPE_CUBE_ARRAY) }, 578 { IMAGE_TYPE_3D, { tcu::UVec3(256u, 256u, 16u), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u, 137u, 3u) }, getTestFormats(IMAGE_TYPE_3D) } 579 }; 580 581 for (size_t imageTypeNdx = 0; imageTypeNdx < imageParameters.size(); ++imageTypeNdx) 582 { 583 const ImageType imageType = imageParameters[imageTypeNdx].imageType; 584 de::MovePtr<tcu::TestCaseGroup> imageTypeGroup(new tcu::TestCaseGroup(testCtx, getImageTypeName(imageType).c_str())); 585 586 for (size_t formatNdx = 0; formatNdx < imageParameters[imageTypeNdx].formats.size(); ++formatNdx) 587 { 588 VkFormat format = imageParameters[imageTypeNdx].formats[formatNdx].format; 589 tcu::UVec3 imageSizeAlignment = getImageSizeAlignment(format); 590 de::MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, getImageFormatID(format).c_str())); 591 592 for (size_t imageSizeNdx = 0; imageSizeNdx < imageParameters[imageTypeNdx].imageSizes.size(); ++imageSizeNdx) 593 { 594 const tcu::UVec3 imageSize = imageParameters[imageTypeNdx].imageSizes[imageSizeNdx]; 595 596 // skip test for images with odd sizes for some YCbCr formats 597 if ((imageSize.x() % imageSizeAlignment.x()) != 0) 598 continue; 599 if ((imageSize.y() % imageSizeAlignment.y()) != 0) 600 continue; 601 602 std::ostringstream stream; 603 stream << imageSize.x() << "_" << imageSize.y() << "_" << imageSize.z(); 604 605 formatGroup->addChild(new MipmapSparseResidencyCase(testCtx, stream.str(), imageType, imageSize, format, useDeviceGroup)); 606 } 607 imageTypeGroup->addChild(formatGroup.release()); 608 } 609 testGroup->addChild(imageTypeGroup.release()); 610 } 611 612 return testGroup.release(); 613} 614 615tcu::TestCaseGroup* createMipmapSparseResidencyTests (tcu::TestContext& testCtx) 616{ 617 de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "mipmap_sparse_residency")); 618 return createMipmapSparseResidencyTestsCommon(testCtx, testGroup); 619} 620 621tcu::TestCaseGroup* createDeviceGroupMipmapSparseResidencyTests (tcu::TestContext& testCtx) 622{ 623 de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "device_group_mipmap_sparse_residency")); 624 return createMipmapSparseResidencyTestsCommon(testCtx, testGroup, true); 625} 626 627} // sparse 628} // vkt 629