Support use of non-coherent memory allocations in Vulkan.

src/gpu/vk/GrVkGpu.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrVkGpu.h"
 
 #include "GrContextOptions.h"
@@ skipping 469 matching lines @@
     } else {
         // If there is no padding on the src (rowBytes) or dst (layout.rowPitch) we can memcpy
         if (trimRowBytes == rowBytes && trimRowBytes == layout.rowPitch) {
             memcpy(mapPtr, data, trimRowBytes * height);
         } else {
             SkRectMemcpy(mapPtr, static_cast<size_t>(layout.rowPitch), data, rowBytes, trimRowBytes,
                          height);
         }
     }
 
+    GrVkMemory::FlushMappedAlloc(this, alloc);
     GR_VK_CALL(interface, UnmapMemory(fDevice, alloc.fMemory));
 
     return true;
 }
 
 bool GrVkGpu::uploadTexDataOptimal(GrVkTexture* tex,
                                    int left, int top, int width, int height,
                                    GrPixelConfig dataConfig,
                                    const SkTArray<GrMipLevel>& texels) {
     SkASSERT(!tex->isLinearTiled());
@@ skipping 92 matching lines @@
         region.bufferRowLength = currentWidth;
         region.bufferImageHeight = currentHeight;
         region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, SkToU32(currentMipLevel), 0, 1 };
         region.imageOffset = { left, flipY ? tex->height() - top - currentHeight : top, 0 };
         region.imageExtent = { (uint32_t)currentWidth, (uint32_t)currentHeight, 1 };
 
         currentWidth = SkTMax(1, currentWidth/2);
         currentHeight = SkTMax(1, currentHeight/2);
     }
 
+    // no need to flush non-coherent memory, unmap will do that for us
     transferBuffer->unmap();
 
     // Change layout of our target so it can be copied to
     tex->setImageLayout(this,
                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                         VK_ACCESS_TRANSFER_WRITE_BIT,
                         VK_PIPELINE_STAGE_TRANSFER_BIT,
                         false);
 
     // Copy the buffer to the image
@@ skipping 337 matching lines @@
                                                                  width,
                                                                  height,
                                                                  samples,
                                                                  sFmt));
     fStats.incStencilAttachmentCreates();
     return stencil;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-bool copy_testing_data(GrVkGpu* gpu, void* srcData, GrVkAlloc* alloc,
+bool copy_testing_data(GrVkGpu* gpu, void* srcData, const GrVkAlloc& alloc,
                        size_t srcRowBytes, size_t dstRowBytes, int h) {
     void* mapPtr;
     VkResult err = GR_VK_CALL(gpu->vkInterface(), MapMemory(gpu->device(),
-                                                            alloc->fMemory,
-                                                            alloc->fOffset,
+                                                            alloc.fMemory,
+                                                            alloc.fOffset,
                                                             dstRowBytes * h,
                                                             0,
                                                             &mapPtr));
     if (err) {
         return false;
     }
 
     // If there is no padding on dst we can do a single memcopy.
     // This assumes the srcData comes in with no padding.
     if (srcRowBytes == dstRowBytes) {
         memcpy(mapPtr, srcData, srcRowBytes * h);
     } else {
         SkRectMemcpy(mapPtr, static_cast<size_t>(dstRowBytes), srcData, srcRowBytes,
                      srcRowBytes, h);
     }
-    GR_VK_CALL(gpu->vkInterface(), UnmapMemory(gpu->device(), alloc->fMemory));
+    GrVkMemory::FlushMappedAlloc(gpu, alloc);
+    GR_VK_CALL(gpu->vkInterface(), UnmapMemory(gpu->device(), alloc.fMemory));
     return true;
 }
 
 GrBackendObject GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, int h,
                                                          GrPixelConfig config,
                                                          bool isRenderTarget) {
 
     VkFormat pixelFormat;
     if (!GrPixelConfigToVkFormat(config, &pixelFormat)) {
         return 0;
@@ skipping 14 matching lines @@
     }
 
     VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT;
     usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
     usageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
     if (isRenderTarget) {
         usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
     }
 
     VkImage image = VK_NULL_HANDLE;
-    GrVkAlloc alloc = { VK_NULL_HANDLE, 0, 0 };
+    GrVkAlloc alloc = { VK_NULL_HANDLE, 0, 0, 0 };
 
     VkImageTiling imageTiling = linearTiling ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
     VkImageLayout initialLayout = (VK_IMAGE_TILING_LINEAR == imageTiling)
                                 ? VK_IMAGE_LAYOUT_PREINITIALIZED
                                 : VK_IMAGE_LAYOUT_UNDEFINED;
 
     // Create Image
     VkSampleCountFlagBits vkSamples;
     if (!GrSampleCountToVkSampleCount(1, &vkSamples)) {
         return 0;
@@ skipping 30 matching lines @@
         if (linearTiling) {
             const VkImageSubresource subres = {
                 VK_IMAGE_ASPECT_COLOR_BIT,
                 0,  // mipLevel
                 0,  // arraySlice
             };
             VkSubresourceLayout layout;
 
             VK_CALL(GetImageSubresourceLayout(fDevice, image, &subres, &layout));
 
-            if (!copy_testing_data(this, srcData, &alloc, rowCopyBytes,
+            if (!copy_testing_data(this, srcData, alloc, rowCopyBytes,
                                    static_cast<size_t>(layout.rowPitch), h)) {
                 GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
                 VK_CALL(DestroyImage(fDevice, image, nullptr));
                 return 0;
             }
         } else {
             SkASSERT(w && h);
 
             VkBuffer buffer;
             VkBufferCreateInfo bufInfo;
             memset(&bufInfo, 0, sizeof(VkBufferCreateInfo));
             bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
             bufInfo.flags = 0;
             bufInfo.size = rowCopyBytes * h;
             bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
             bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
             bufInfo.queueFamilyIndexCount = 0;
             bufInfo.pQueueFamilyIndices = nullptr;
             VkResult err;
             err = VK_CALL(CreateBuffer(fDevice, &bufInfo, nullptr, &buffer));
 
             if (err) {
                 GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
                 VK_CALL(DestroyImage(fDevice, image, nullptr));
                 return 0;
             }
 
-            GrVkAlloc bufferAlloc = { VK_NULL_HANDLE, 0, 0 };
+            GrVkAlloc bufferAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
             if (!GrVkMemory::AllocAndBindBufferMemory(this, buffer, GrVkBuffer::kCopyRead_Type,
                                                       true, &bufferAlloc)) {
                 GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
                 VK_CALL(DestroyImage(fDevice, image, nullptr));
                 VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
                 return 0;
             }
 
-            if (!copy_testing_data(this, srcData, &bufferAlloc, rowCopyBytes, rowCopyBytes, h)) {
+            if (!copy_testing_data(this, srcData, bufferAlloc, rowCopyBytes, rowCopyBytes, h)) {
                 GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
                 VK_CALL(DestroyImage(fDevice, image, nullptr));
                 GrVkMemory::FreeBufferMemory(this, GrVkBuffer::kCopyRead_Type, bufferAlloc);
                 VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
                 return 0;
             }
 
             const VkCommandBufferAllocateInfo cmdInfo = {
                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // sType
                 NULL,                                             // pNext
@@ skipping 628 matching lines @@
     transferBuffer->addMemoryBarrier(this,
                                      VK_ACCESS_TRANSFER_WRITE_BIT,
                                      VK_ACCESS_HOST_READ_BIT,
                                      VK_PIPELINE_STAGE_TRANSFER_BIT,
                                      VK_PIPELINE_STAGE_HOST_BIT,
                                      false);
 
     // We need to submit the current command buffer to the Queue and make sure it finishes before
     // we can copy the data out of the buffer.
     this->submitCommandBuffer(kForce_SyncQueue);
-
+    GrVkMemory::InvalidateMappedAlloc(this, transferBuffer->alloc());

[egdaniel, 2016/09/20 15:23:22]

Is this a call we can put into map similar to Flush and unmap?

[jvanverth1, 2016/09/20 15:30:54]

I left it outside because we often map to write, and only occasionally to read,
and I didn't want to pay any perf cost for invalidating unless we need it.

     void* mappedMemory = transferBuffer->map();
 
     if (copyFromOrigin) {
         uint32_t skipRows = region.imageExtent.height - height;
         mappedMemory = (char*)mappedMemory + transBufferRowBytes * skipRows + bpp * left;
     }
 
     if (flipY) {
         const char* srcRow = reinterpret_cast<const char*>(mappedMemory);
         char* dstRow = reinterpret_cast<char*>(buffer)+(height - 1) * rowBytes;
@@ skipping 78 matching lines @@
     // Currently it is fine for us to always pass in 1 for the clear count even if no attachment
     // uses it. In the current state, we also only use the LOAD_OP_CLEAR for the color attachment
     // which is always at the first attachment.
     fCurrentCmdBuffer->beginRenderPass(this, renderPass, 1, colorClear, *target, *pBounds, true);
     fCurrentCmdBuffer->executeCommands(this, buffer);
     fCurrentCmdBuffer->endRenderPass(this);
 
     this->didWriteToSurface(target, &bounds);
 }