Add offset to memory allocations

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 313 matching lines @@
     VkResult err;
 
     const GrVkInterface* interface = this->vkInterface();
 
     GR_VK_CALL(interface, GetImageSubresourceLayout(fDevice,
                                                     tex->image(),
                                                     &subres,
                                                     &layout));
 
     int texTop = kBottomLeft_GrSurfaceOrigin == desc.fOrigin ? tex->height() - top - height : top;
-    VkDeviceSize offset = texTop*layout.rowPitch + left*bpp;
+    const GrVkAlloc& alloc = tex->alloc();
+    VkDeviceSize offset = alloc.fOffset + texTop*layout.rowPitch + left*bpp;
     VkDeviceSize size = height*layout.rowPitch;
     void* mapPtr;
-    err = GR_VK_CALL(interface, MapMemory(fDevice, tex->memory(), offset, size, 0, &mapPtr));
+    err = GR_VK_CALL(interface, MapMemory(fDevice, alloc.fMemory, offset, size, 0, &mapPtr));
     if (err) {
         return false;
     }
 
     if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
         // copy into buffer by rows
         const char* srcRow = reinterpret_cast<const char*>(data);
         char* dstRow = reinterpret_cast<char*>(mapPtr)+(height - 1)*layout.rowPitch;
         for (int y = 0; y < height; y++) {
             memcpy(dstRow, srcRow, trimRowBytes);
             srcRow += rowBytes;
             dstRow -= layout.rowPitch;
         }
     } 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);
         }
     }
 
-    GR_VK_CALL(interface, UnmapMemory(fDevice, tex->memory()));
+    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());
     // The assumption is either that we have no mipmaps, or that our rect is the entire texture
@@ skipping 238 matching lines @@
     if (0 == desc.fTextureHandle) {
         return nullptr;
     }
 
     int maxSize = this->caps()->maxTextureSize();
     if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
         return nullptr;
     }
 
     const GrVkImageInfo* info = reinterpret_cast<const GrVkImageInfo*>(desc.fTextureHandle);
-    if (VK_NULL_HANDLE == info->fImage || VK_NULL_HANDLE == info->fAlloc) {
+    if (VK_NULL_HANDLE == info->fImage || VK_NULL_HANDLE == info->fAlloc.fMemory) {
         return nullptr;
     }
 #ifdef SK_DEBUG
     VkFormat format;
     if (!GrPixelConfigToVkFormat(desc.fConfig, &format)) {
         return nullptr;
     }
     SkASSERT(format == info->fFormat);
 #endif
 
@@ skipping 22 matching lines @@
 
     return texture;
 }
 
 GrRenderTarget* GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc,
                                                    GrWrapOwnership ownership) {
 
     const GrVkImageInfo* info =
         reinterpret_cast<const GrVkImageInfo*>(wrapDesc.fRenderTargetHandle);
     if (VK_NULL_HANDLE == info->fImage ||
-        (VK_NULL_HANDLE == info->fAlloc && kAdopt_GrWrapOwnership == ownership)) {
+        (VK_NULL_HANDLE == info->fAlloc.fMemory && kAdopt_GrWrapOwnership == ownership)) {
         return nullptr;
     }
 
     GrSurfaceDesc desc;
     desc.fConfig = wrapDesc.fConfig;
     desc.fFlags = kCheckAllocation_GrSurfaceFlag;
     desc.fWidth = wrapDesc.fWidth;
     desc.fHeight = wrapDesc.fHeight;
     desc.fSampleCnt = SkTMin(wrapDesc.fSampleCnt, this->caps()->maxSampleCount());
 
@@ skipping 192 matching lines @@
     }
 
     VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT;
     usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
     usageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
     VkFlags memProps = (srcData && linearTiling) ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT :
                                                    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
 
     VkImage image = VK_NULL_HANDLE;
-    VkDeviceMemory alloc = VK_NULL_HANDLE;
+    GrVkAlloc alloc = { VK_NULL_HANDLE, 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 @@
                 VK_IMAGE_ASPECT_COLOR_BIT,
                 0,  // mipLevel
                 0,  // arraySlice
             };
             VkSubresourceLayout layout;
             VkResult err;
 
             VK_CALL(GetImageSubresourceLayout(fDevice, image, &subres, &layout));
 
             void* mapPtr;
-            err = VK_CALL(MapMemory(fDevice, alloc, 0, layout.rowPitch * h, 0, &mapPtr));
+            err = VK_CALL(MapMemory(fDevice, alloc.fMemory, alloc.fOffset, layout.rowPitch * h,
+                                    0, &mapPtr));
             if (err) {
-                VK_CALL(FreeMemory(this->device(), alloc, nullptr));
+                GrVkMemory::FreeImageMemory(this, alloc);
                 VK_CALL(DestroyImage(this->device(), image, nullptr));
                 return 0;
             }
 
             size_t bpp = GrBytesPerPixel(config);
             size_t rowCopyBytes = bpp * w;
             // If there is no padding on dst (layout.rowPitch) we can do a single memcopy.
             // This assumes the srcData comes in with no padding.
             if (rowCopyBytes == layout.rowPitch) {
                 memcpy(mapPtr, srcData, rowCopyBytes * h);
             } else {
                 SkRectMemcpy(mapPtr, static_cast<size_t>(layout.rowPitch), srcData, rowCopyBytes,
                              rowCopyBytes, h);
             }
-            VK_CALL(UnmapMemory(fDevice, alloc));
+            VK_CALL(UnmapMemory(fDevice, alloc.fMemory));
         } else {
             // TODO: Add support for copying to optimal tiling
             SkASSERT(false);
         }
     }
 
     GrVkImageInfo* info = new GrVkImageInfo;
     info->fImage = image;
     info->fAlloc = alloc;
     info->fImageTiling = imageTiling;
     info->fImageLayout = initialLayout;
     info->fFormat = pixelFormat;
     info->fLevelCount = 1;
 
     return (GrBackendObject)info;
 }
 
 bool GrVkGpu::isTestingOnlyBackendTexture(GrBackendObject id) const {
     const GrVkImageInfo* backend = reinterpret_cast<const GrVkImageInfo*>(id);
 
-    if (backend && backend->fImage && backend->fAlloc) {
+    if (backend && backend->fImage && backend->fAlloc.fMemory) {
         VkMemoryRequirements req;
         memset(&req, 0, sizeof(req));
         GR_VK_CALL(this->vkInterface(), GetImageMemoryRequirements(fDevice,
                                                                    backend->fImage,
                                                                    &req));
         // TODO: find a better check
         // This will probably fail with a different driver
         return (req.size > 0) && (req.size <= 8192 * 8192);
     }
 
     return false;
 }
 
 void GrVkGpu::deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandon) {
     const GrVkImageInfo* backend = reinterpret_cast<const GrVkImageInfo*>(id);
 
     if (backend) {
         if (!abandon) {
             // something in the command buffer may still be using this, so force submit
             this->submitCommandBuffer(kForce_SyncQueue);
 
-            VK_CALL(FreeMemory(this->device(), backend->fAlloc, nullptr));
+            GrVkMemory::FreeImageMemory(this, backend->fAlloc);
             VK_CALL(DestroyImage(this->device(), backend->fImage, nullptr));
         }
         delete backend;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrVkGpu::addMemoryBarrier(VkPipelineStageFlags srcStageMask,
                                VkPipelineStageFlags dstStageMask,
@@ skipping 687 matching lines @@
     aglSwapBuffers(aglGetCurrentContext());
     int set_a_break_pt_here = 9;
     aglSwapBuffers(aglGetCurrentContext());
 #elif defined(SK_BUILD_FOR_WIN32)
     SwapBuf();
     int set_a_break_pt_here = 9;
     SwapBuf();
 #endif
 #endif
 }