Add create functions for common Vulkan types.

[platform/upstream/VK-GL-CTS.git] / external / vulkancts / modules / vulkan / sparse_resources / vktSparseResourcesImageSparseBinding.cpp

diff --git a/external/vulkancts/modules/vulkan/sparse_resources/vktSparseResourcesImageSparseBinding.cpp b/external/vulkancts/modules/vulkan/sparse_resources/vktSparseResourcesImageSparseBinding.cpp
index e761990..37b47b6 100644 (file)
--- a/external/vulkancts/modules/vulkan/sparse_resources/vktSparseResourcesImageSparseBinding.cpp
+++ b/external/vulkancts/modules/vulkan/sparse_resources/vktSparseResourcesImageSparseBinding.cpp
@@ -112,11 +112,10 @@ ImageSparseBindingInstance::ImageSparseBindingInstance (Context&                                  context,
 
 tcu::TestStatus ImageSparseBindingInstance::iterate (void)
 {
-       const InstanceInterface&                        instance                = m_context.getInstanceInterface();
-       const DeviceInterface&                          deviceInterface = m_context.getDeviceInterface();
-       const VkPhysicalDevice                          physicalDevice  = m_context.getPhysicalDevice();
-       VkImageCreateInfo                                       imageSparseInfo;
-       std::vector<DeviceMemoryUniquePtr>      deviceMemUniquePtrVec;
+       const InstanceInterface&        instance                = m_context.getInstanceInterface();
+       const VkPhysicalDevice          physicalDevice  = m_context.getPhysicalDevice();
+       VkImageCreateInfo                       imageSparseInfo;
+       std::vector<DeviceMemorySp>     deviceMemUniquePtrVec;
 
        // Check if image size does not exceed device limits
        if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
@@ -135,10 +134,9 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
                createDeviceSupportingQueues(queueRequirements);
        }
 
-       const de::UniquePtr<Allocator> allocator(new SimpleAllocator(deviceInterface, *m_logicalDevice, getPhysicalDeviceMemoryProperties(instance, physicalDevice)));
-
-       const Queue& sparseQueue        = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
-       const Queue& computeQueue       = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
+       const DeviceInterface&  deviceInterface = getDeviceInterface();
+       const Queue&                    sparseQueue             = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
+       const Queue&                    computeQueue    = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
 
        imageSparseInfo.sType                                   = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;                                  //VkStructureType               sType;
        imageSparseInfo.pNext                                   = DE_NULL;                                                                                              //const void*                   pNext;
@@ -175,13 +173,13 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
        }
 
        // Create sparse image
-       const Unique<VkImage> imageSparse(createImage(deviceInterface, *m_logicalDevice, &imageSparseInfo));
+       const Unique<VkImage> imageSparse(createImage(deviceInterface, getDevice(), &imageSparseInfo));
 
        // Create sparse image memory bind semaphore
-       const Unique<VkSemaphore> imageMemoryBindSemaphore(makeSemaphore(deviceInterface, *m_logicalDevice));
+       const Unique<VkSemaphore> imageMemoryBindSemaphore(createSemaphore(deviceInterface, getDevice()));
 
        // Get sparse image general memory requirements
-       const VkMemoryRequirements imageSparseMemRequirements = getImageMemoryRequirements(deviceInterface, *m_logicalDevice, *imageSparse);
+       const VkMemoryRequirements imageSparseMemRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
 
        // Check if required image memory size does not exceed device limits
        if (imageSparseMemRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
@@ -199,10 +197,10 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
 
                for (deUint32 sparseBindNdx = 0; sparseBindNdx < numSparseBinds; ++sparseBindNdx)
                {
-                       const VkSparseMemoryBind sparseMemoryBind = makeSparseMemoryBind(deviceInterface, *m_logicalDevice,
+                       const VkSparseMemoryBind sparseMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
                                imageSparseMemRequirements.alignment, memoryType, imageSparseMemRequirements.alignment * sparseBindNdx);
 
-                       deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(sparseMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, *m_logicalDevice, DE_NULL))));
+                       deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(sparseMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
 
                        sparseMemoryBinds.push_back(sparseMemoryBind);
                }
@@ -230,8 +228,8 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
        }
 
        // Create command buffer for compute and transfer oparations
-       const Unique<VkCommandPool>       commandPool(makeCommandPool(deviceInterface, *m_logicalDevice, computeQueue.queueFamilyIndex));
-       const Unique<VkCommandBuffer> commandBuffer(makeCommandBuffer(deviceInterface, *m_logicalDevice, *commandPool));
+       const Unique<VkCommandPool>       commandPool(makeCommandPool(deviceInterface, getDevice(), computeQueue.queueFamilyIndex));
+       const Unique<VkCommandBuffer> commandBuffer(allocateCommandBuffer(deviceInterface, getDevice(), *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
 
        std::vector<VkBufferImageCopy> bufferImageCopy(imageSparseInfo.mipLevels);
 
@@ -240,17 +238,17 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
                for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; mipmapNdx++)
                {
                        bufferImageCopy[mipmapNdx] = makeBufferImageCopy(mipLevelExtents(imageSparseInfo.extent, mipmapNdx), imageSparseInfo.arrayLayers, mipmapNdx, static_cast<VkDeviceSize>(bufferOffset));
-                       bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipmapNdx, MEM_ALIGN_BUFFERIMAGECOPY_OFFSET);
+                       bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
                }
        }
 
        // Start recording commands
        beginCommandBuffer(deviceInterface, *commandBuffer);
 
-       const deUint32                          imageSizeInBytes                = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels, MEM_ALIGN_BUFFERIMAGECOPY_OFFSET);
-       const VkBufferCreateInfo        inputBufferCreateInfo   = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
-
-       const de::UniquePtr<Buffer>     inputBuffer(new Buffer(deviceInterface, *m_logicalDevice, *allocator, inputBufferCreateInfo, MemoryRequirement::HostVisible));
+       const deUint32                                  imageSizeInBytes                = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
+       const VkBufferCreateInfo                inputBufferCreateInfo   = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
+       const Unique<VkBuffer>                  inputBuffer                             (createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo));
+       const de::UniquePtr<Allocation> inputBufferAlloc                (bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible));
 
        std::vector<deUint8> referenceData(imageSizeInBytes);
 
@@ -259,16 +257,16 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
                referenceData[valueNdx] = static_cast<deUint8>((valueNdx % imageSparseMemRequirements.alignment) + 1u);
        }
 
-       deMemcpy(inputBuffer->getAllocation().getHostPtr(), &referenceData[0], imageSizeInBytes);
+       deMemcpy(inputBufferAlloc->getHostPtr(), &referenceData[0], imageSizeInBytes);
 
-       flushMappedMemoryRange(deviceInterface, *m_logicalDevice, inputBuffer->getAllocation().getMemory(), inputBuffer->getAllocation().getOffset(), imageSizeInBytes);
+       flushMappedMemoryRange(deviceInterface, getDevice(), inputBufferAlloc->getMemory(), inputBufferAlloc->getOffset(), imageSizeInBytes);
 
        {
                const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier
                (
                        VK_ACCESS_HOST_WRITE_BIT,
                        VK_ACCESS_TRANSFER_READ_BIT,
-                       inputBuffer->get(),
+                       *inputBuffer,
                        0u,
                        imageSizeInBytes
                );
@@ -292,7 +290,7 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
                deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferDstBarrier);
        }
 
-       deviceInterface.cmdCopyBufferToImage(*commandBuffer, inputBuffer->get(), *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
+       deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
 
        {
                const VkImageMemoryBarrier imageSparseTransferSrcBarrier = makeImageMemoryBarrier
@@ -308,17 +306,18 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
                deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferSrcBarrier);
        }
 
-       const VkBufferCreateInfo        outputBufferCreateInfo = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
-       const de::UniquePtr<Buffer>     outputBuffer(new Buffer(deviceInterface, *m_logicalDevice, *allocator, outputBufferCreateInfo, MemoryRequirement::HostVisible));
+       const VkBufferCreateInfo                outputBufferCreateInfo  = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
+       const Unique<VkBuffer>                  outputBuffer                    (createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo));
+       const de::UniquePtr<Allocation> outputBufferAlloc               (bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible));
 
-       deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, outputBuffer->get(), static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
+       deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
 
        {
                const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier
                (
                        VK_ACCESS_TRANSFER_WRITE_BIT,
                        VK_ACCESS_HOST_READ_BIT,
-                       outputBuffer->get(),
+                       *outputBuffer,
                        0u,
                        imageSizeInBytes
                );
@@ -332,13 +331,12 @@ tcu::TestStatus ImageSparseBindingInstance::iterate (void)
        const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT };
 
        // Submit commands for execution and wait for completion
-       submitCommandsAndWait(deviceInterface, *m_logicalDevice, computeQueue.queueHandle, *commandBuffer, 1u, &imageMemoryBindSemaphore.get(), stageBits);
+       submitCommandsAndWait(deviceInterface, getDevice(), computeQueue.queueHandle, *commandBuffer, 1u, &imageMemoryBindSemaphore.get(), stageBits);
 
        // Retrieve data from buffer to host memory
-       const Allocation& allocation = outputBuffer->getAllocation();
-       invalidateMappedMemoryRange(deviceInterface, *m_logicalDevice, allocation.getMemory(), allocation.getOffset(), imageSizeInBytes);
+       invalidateMappedMemoryRange(deviceInterface, getDevice(), outputBufferAlloc->getMemory(), outputBufferAlloc->getOffset(), imageSizeInBytes);
 
-       const deUint8* outputData = static_cast<const deUint8*>(allocation.getHostPtr());
+       const deUint8* outputData = static_cast<const deUint8*>(outputBufferAlloc->getHostPtr());
 
        // Wait for sparse queue to become idle
        deviceInterface.queueWaitIdle(sparseQueue.queueHandle);