VulkanMemory.h

Go to the documentation of this file.

/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
 
#ifndef skgpu_VulkanMemory_DEFINED
#define skgpu_VulkanMemory_DEFINED
 
#include "include/gpu/GpuTypes.h"
#include "include/gpu/vk/VulkanMemoryAllocator.h"
#include "include/gpu/vk/VulkanTypes.h"
#include "include/private/base/SkTArray.h"
 
#include <functional>
 
namespace skgpu {
 
namespace VulkanMemory {
    using CheckResult = bool(VkResult);
 
    bool AllocBufferMemory(VulkanMemoryAllocator*,
                           VkBuffer buffer,
                           skgpu::VulkanMemoryAllocator::BufferUsage,
                           bool shouldPersistentlyMapCpuToGpu,
                           const std::function<CheckResult>&,
                           VulkanAlloc* alloc);
 
    void FreeBufferMemory(VulkanMemoryAllocator*, const VulkanAlloc& alloc);
 
    bool AllocImageMemory(VulkanMemoryAllocator*,
                          VkImage image,
                          skgpu::Protected isProtected,
                          bool forceDedicatedMemory,
                          bool useLazyAllocation,
                          const std::function<CheckResult>&,
                          VulkanAlloc* alloc);
 
    void FreeImageMemory(VulkanMemoryAllocator*, const VulkanAlloc& alloc);
 
    // Maps the entire skgpu::VulkanAlloc and returns a pointer to the start of the allocation.
    // Underneath the hood, we may map more than the range of the skgpu::VulkanAlloc (e.g. the
    // entire VkDeviceMemory), but the pointer returned will always be to the start of the
    // skgpu::VulkanAlloc. The caller should also never assume more than the skgpu::VulkanAlloc
    // block has been mapped.
    void* MapAlloc(VulkanMemoryAllocator*,
                   const VulkanAlloc&,
                   const std::function<CheckResult>&);
    void UnmapAlloc(VulkanMemoryAllocator*, const VulkanAlloc& alloc);
 
    // For the Flush and Invalidate calls, the offset should be relative to the skgpu::VulkanAlloc.
    // Thus this will often be 0. The client does not need to make sure the offset and size are
    // aligned to the nonCoherentAtomSize, the internal calls will handle that.
    void FlushMappedAlloc(VulkanMemoryAllocator*,
                          const skgpu::VulkanAlloc&,
                          VkDeviceSize offset,
                          VkDeviceSize size,
                          const std::function<CheckResult>&);
    void InvalidateMappedAlloc(VulkanMemoryAllocator*,
                               const VulkanAlloc& alloc,
                               VkDeviceSize offset,
                               VkDeviceSize size,
                               const std::function<CheckResult>&);
 
    // Helper for aligning and setting VkMappedMemoryRange for flushing/invalidating noncoherent
    // memory.
    void GetNonCoherentMappedMemoryRange(const VulkanAlloc&,
                                         VkDeviceSize offset,
                                         VkDeviceSize size,
                                         VkDeviceSize alignment,
                                         VkMappedMemoryRange*);
}  // namespace VulkanMemory
 
}  // namespace skgpu
 
#endif