Vulkan: Clean up VMA wrapper classes.

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -505,7 +505,7 @@ void RendererVk::onDestroy()
     mPipelineCache.destroy(mDevice);
     mSamplerCache.destroy(this);
 
-    vma::DestroyAllocator(mAllocator);
+    mAllocator.destroy();
 
     if (mGlslangInitialized)
     {
@@ -825,7 +825,7 @@ angle::Result RendererVk::initialize(DisplayVk *displayVk,
     }
 
     // Create VMA allocator
-    ANGLE_VK_TRY(displayVk, vma::InitAllocator(mPhysicalDevice, mDevice, mInstance, &mAllocator));
+    ANGLE_VK_TRY(displayVk, mAllocator.init(mPhysicalDevice, mDevice, mInstance));
 
     // Store the physical device memory properties so we can find the right memory pools.
     mMemoryProperties.init(mPhysicalDevice);

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -106,7 +106,7 @@ class RendererVk : angle::NonCopyable
     }
     VkDevice getDevice() const { return mDevice; }
 
-    const VmaAllocator &getAllocator() const { return mAllocator; }
+    const vk::Allocator &getAllocator() const { return mAllocator; }
 
     angle::Result selectPresentQueueForSurface(DisplayVk *displayVk,
                                                VkSurfaceKHR surface,
@@ -376,7 +376,7 @@ class RendererVk : angle::NonCopyable
     // track whether we initialized (or released) glslang
     bool mGlslangInitialized;
 
-    VmaAllocator mAllocator;
+    vk::Allocator mAllocator;
     SamplerCache mSamplerCache;
     vk::ActiveHandleCounter mActiveHandleCounts;
 };

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -2151,10 +2151,14 @@ angle::Result BufferHelper::init(Context *context,
     VkMemoryPropertyFlags preferredFlags =
         (memoryPropertyFlags & (~VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
 
-    mAllocation.createBufferAndMemory(
-        renderer->getAllocator(), createInfo, requiredFlags, preferredFlags,
-        renderer->getFeatures().persistentlyMappedBuffers.enabled, &mBuffer, &mMemoryPropertyFlags);
-
+    const vk::Allocator &allocator = renderer->getAllocator();
+    uint32_t memoryTypeIndex       = 0;
+    ANGLE_VK_TRY(context,
+                 allocator.createBuffer(*createInfo, requiredFlags, preferredFlags,
+                                        renderer->getFeatures().persistentlyMappedBuffers.enabled,
+                                        &memoryTypeIndex, &mBuffer, &mAllocation));
+
+    allocator.getMemoryTypeProperties(memoryTypeIndex, &mMemoryPropertyFlags);
     mCurrentQueueFamilyIndex = renderer->getQueueFamilyIndex();
 
     if (renderer->getFeatures().allocateNonZeroMemory.enabled)
@@ -2172,8 +2176,8 @@ angle::Result BufferHelper::init(Context *context,
             // Can map the memory.
             // Pick an arbitrary value to initialize non-zero memory for sanitization.
             constexpr int kNonZeroInitValue = 55;
-            ANGLE_TRY(InitMappableAllocation(renderer->getAllocator(), &mAllocation, mSize,
-                                             kNonZeroInitValue, mMemoryPropertyFlags));
+            ANGLE_TRY(InitMappableAllocation(allocator, &mAllocation, mSize, kNonZeroInitValue,
+                                             mMemoryPropertyFlags));
         }
     }
 

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -409,16 +409,18 @@ angle::Result StagingBuffer::init(Context *context, VkDeviceSize size, StagingUs
     createInfo.queueFamilyIndexCount = 0;
     createInfo.pQueueFamilyIndices   = nullptr;
 
-    VkMemoryPropertyFlags memoryPropertyOutFlags;
     VkMemoryPropertyFlags preferredFlags = 0;
     VkMemoryPropertyFlags requiredFlags =
         VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
 
-    mAllocation.createBufferAndMemory(
-        context->getRenderer()->getAllocator(), &createInfo, requiredFlags, preferredFlags,
-        context->getRenderer()->getFeatures().persistentlyMappedBuffers.enabled, &mBuffer,
-        &memoryPropertyOutFlags);
+    RendererVk *renderer           = context->getRenderer();
+    const vk::Allocator &allocator = renderer->getAllocator();
 
+    uint32_t memoryTypeIndex = 0;
+    ANGLE_VK_TRY(context,
+                 allocator.createBuffer(createInfo, requiredFlags, preferredFlags,
+                                        renderer->getFeatures().persistentlyMappedBuffers.enabled,
+                                        &memoryTypeIndex, &mBuffer, &mAllocation));
     mSize = static_cast<size_t>(size);
     return angle::Result::Continue;
 }
@@ -441,7 +443,7 @@ void StagingBuffer::collectGarbage(RendererVk *renderer, Serial serial)
     renderer->collectGarbage(std::move(sharedUse), std::move(garbageList));
 }
 
-angle::Result InitMappableAllocation(VmaAllocator allocator,
+angle::Result InitMappableAllocation(const vk::Allocator &allocator,
                                      Allocation *allocation,
                                      VkDeviceSize size,
                                      int value,
@@ -653,7 +655,7 @@ void GarbageObject::destroy(RendererVk *renderer)
             vkDestroyQueryPool(device, (VkQueryPool)mHandle, nullptr);
             break;
         case HandleType::Allocation:
-            vma::FreeMemory(renderer->getAllocator(), (VmaAllocation)mHandle);
+            vma::FreeMemory(renderer->getAllocator().getHandle(), (VmaAllocation)mHandle);
             break;
         default:
             UNREACHABLE();

src/libANGLE/renderer/vulkan/vk_utils.h

@@ -317,8 +317,8 @@ class StagingBuffer final : angle::NonCopyable
     size_t mSize;
 };
 
-angle::Result InitMappableAllocation(VmaAllocator allocator,
-                                     Allocation *allcation,
+angle::Result InitMappableAllocation(const vk::Allocator &allocator,
+                                     Allocation *allocation,
                                      VkDeviceSize size,
                                      int value,
                                      VkMemoryPropertyFlags memoryPropertyFlags);

src/libANGLE/renderer/vulkan/vk_wrapper.h

@@ -28,6 +28,8 @@ namespace vk
 // DescriptorSet
 
 #define ANGLE_HANDLE_TYPES_X(FUNC) \
+    FUNC(Allocation)               \
+    FUNC(Allocator)                \
     FUNC(Buffer)                   \
     FUNC(BufferView)               \
     FUNC(CommandPool)              \
@@ -46,8 +48,7 @@ namespace vk
     FUNC(RenderPass)               \
     FUNC(Sampler)                  \
     FUNC(Semaphore)                \
-    FUNC(ShaderModule)             \
-    FUNC(Allocation)
+    FUNC(ShaderModule)
 
 #define ANGLE_COMMA_SEP_FUNC(TYPE) TYPE,
 
@@ -457,23 +458,39 @@ class DeviceMemory final : public WrappedObject<DeviceMemory, VkDeviceMemory>
     void unmap(VkDevice device) const;
 };
 
+class Allocator : public WrappedObject<Allocator, VmaAllocator>
+{
+  public:
+    Allocator() = default;
+    void destroy();
+
+    VkResult init(VkPhysicalDevice physicalDevice, VkDevice device, VkInstance instance);
+
+    // Initializes the buffer handle and memory allocation.
+    VkResult createBuffer(const VkBufferCreateInfo &bufferCreateInfo,
+                          VkMemoryPropertyFlags requiredFlags,
+                          VkMemoryPropertyFlags preferredFlags,
+                          bool persistentlyMappedBuffers,
+                          uint32_t *memoryTypeIndexOut,
+                          Buffer *bufferOut,
+                          Allocation *allocationOut) const;
+
+    void getMemoryTypeProperties(uint32_t memoryTypeIndex, VkMemoryPropertyFlags *flagsOut) const;
+};
+
 class Allocation final : public WrappedObject<Allocation, VmaAllocation>
 {
   public:
     Allocation() = default;
-    void destroy(VmaAllocator allocator);
-
-    VkResult createBufferAndMemory(VmaAllocator allocator,
-                                   const VkBufferCreateInfo *pBufferCreateInfo,
-                                   VkMemoryPropertyFlags requiredFlags,
-                                   VkMemoryPropertyFlags preferredFlags,
-                                   bool persistentlyMappedBuffers,
-                                   Buffer *buffer,
-                                   VkMemoryPropertyFlags *pMemPropertyOut);
-    VkResult map(VmaAllocator allocator, uint8_t **mapPointer) const;
-    void unmap(VmaAllocator allocator) const;
-    void flush(VmaAllocator allocator, VkDeviceSize offset, VkDeviceSize size);
-    void invalidate(VmaAllocator allocator, VkDeviceSize offset, VkDeviceSize size);
+    void destroy(const Allocator &allocator);
+
+    VkResult map(const Allocator &allocator, uint8_t **mapPointer) const;
+    void unmap(const Allocator &allocator) const;
+    void flush(const Allocator &allocator, VkDeviceSize offset, VkDeviceSize size);
+    void invalidate(const Allocator &allocator, VkDeviceSize offset, VkDeviceSize size);
+
+  private:
+    friend class Allocator;
 };
 
 class RenderPass final : public WrappedObject<RenderPass, VkRenderPass>
@@ -501,6 +518,9 @@ class Buffer final : public WrappedObject<Buffer, VkBuffer>
     VkResult init(VkDevice device, const VkBufferCreateInfo &createInfo);
     VkResult bindMemory(VkDevice device, const DeviceMemory &deviceMemory);
     void getMemoryRequirements(VkDevice device, VkMemoryRequirements *memoryRequirementsOut);
+
+  private:
+    friend class Allocator;
 };
 
 class BufferView final : public WrappedObject<BufferView, VkBufferView>
@@ -1340,61 +1360,83 @@ ANGLE_INLINE void DeviceMemory::unmap(VkDevice device) const
     vkUnmapMemory(device, mHandle);
 }
 
-// Allocation implementation.
-ANGLE_INLINE void Allocation::destroy(VmaAllocator allocator)
+// Allocator implementation.
+ANGLE_INLINE void Allocator::destroy()
 {
     if (valid())
     {
-        vma::FreeMemory(allocator, mHandle);
+        vma::DestroyAllocator(mHandle);
         mHandle = VK_NULL_HANDLE;
     }
 }
 
-ANGLE_INLINE VkResult Allocation::createBufferAndMemory(VmaAllocator allocator,
-                                                        const VkBufferCreateInfo *pBufferCreateInfo,
-                                                        VkMemoryPropertyFlags requiredFlags,
-                                                        VkMemoryPropertyFlags preferredFlags,
-                                                        bool persistentlyMappedBuffers,
-                                                        Buffer *buffer,
-                                                        VkMemoryPropertyFlags *pMemPropertyOut)
+ANGLE_INLINE VkResult Allocator::init(VkPhysicalDevice physicalDevice,
+                                      VkDevice device,
+                                      VkInstance instance)
 {
     ASSERT(!valid());
-    VkResult result;
-    uint32_t memoryTypeIndex;
-    VkBuffer bufferHandle;
-    result =
-        vma::CreateBuffer(allocator, pBufferCreateInfo, requiredFlags, preferredFlags,
-                          persistentlyMappedBuffers, &memoryTypeIndex, &bufferHandle, &mHandle);
-    vma::GetMemoryTypeProperties(allocator, memoryTypeIndex, pMemPropertyOut);
-    buffer->setHandle(bufferHandle);
+    return vma::InitAllocator(physicalDevice, device, instance, &mHandle);
+}
+
+ANGLE_INLINE VkResult Allocator::createBuffer(const VkBufferCreateInfo &bufferCreateInfo,
+                                              VkMemoryPropertyFlags requiredFlags,
+                                              VkMemoryPropertyFlags preferredFlags,
+                                              bool persistentlyMappedBuffers,
+                                              uint32_t *memoryTypeIndexOut,
+                                              Buffer *bufferOut,
+                                              Allocation *allocationOut) const
+{
+    ASSERT(valid());
+    ASSERT(bufferOut && !bufferOut->valid());
+    ASSERT(allocationOut && !allocationOut->valid());
+    return vma::CreateBuffer(mHandle, &bufferCreateInfo, requiredFlags, preferredFlags,
+                             persistentlyMappedBuffers, memoryTypeIndexOut, &bufferOut->mHandle,
+                             &allocationOut->mHandle);
+}
+
+ANGLE_INLINE void Allocator::getMemoryTypeProperties(uint32_t memoryTypeIndex,
+                                                     VkMemoryPropertyFlags *flagsOut) const
+{
+    ASSERT(valid());
+    vma::GetMemoryTypeProperties(mHandle, memoryTypeIndex, flagsOut);
+}
 
-    return result;
+// Allocation implementation.
+ANGLE_INLINE void Allocation::destroy(const Allocator &allocator)
+{
+    if (valid())
+    {
+        vma::FreeMemory(allocator.getHandle(), mHandle);
+        mHandle = VK_NULL_HANDLE;
+    }
 }
 
-ANGLE_INLINE VkResult Allocation::map(VmaAllocator allocator, uint8_t **mapPointer) const
+ANGLE_INLINE VkResult Allocation::map(const Allocator &allocator, uint8_t **mapPointer) const
 {
     ASSERT(valid());
-    return vma::MapMemory(allocator, mHandle, (void **)mapPointer);
+    return vma::MapMemory(allocator.getHandle(), mHandle, (void **)mapPointer);
 }
 
-ANGLE_INLINE void Allocation::unmap(VmaAllocator allocator) const
+ANGLE_INLINE void Allocation::unmap(const Allocator &allocator) const
 {
     ASSERT(valid());
-    vma::UnmapMemory(allocator, mHandle);
+    vma::UnmapMemory(allocator.getHandle(), mHandle);
 }
 
-ANGLE_INLINE void Allocation::flush(VmaAllocator allocator, VkDeviceSize offset, VkDeviceSize size)
+ANGLE_INLINE void Allocation::flush(const Allocator &allocator,
+                                    VkDeviceSize offset,
+                                    VkDeviceSize size)
 {
     ASSERT(valid());
-    vma::FlushAllocation(allocator, mHandle, offset, size);
+    vma::FlushAllocation(allocator.getHandle(), mHandle, offset, size);
 }
 
-ANGLE_INLINE void Allocation::invalidate(VmaAllocator allocator,
+ANGLE_INLINE void Allocation::invalidate(const Allocator &allocator,
                                          VkDeviceSize offset,
                                          VkDeviceSize size)
 {
     ASSERT(valid());
-    vma::InvalidateAllocation(allocator, mHandle, offset, size);
+    vma::InvalidateAllocation(allocator.getHandle(), mHandle, offset, size);
 }
 
 // RenderPass implementation.