Vulkan: Implement device memory sub-allocation

src/libANGLE/renderer/vulkan/BufferVk.cpp

@@ -294,13 +294,12 @@ angle::Result BufferVk::copySubData(const gl::Context *context,
 
         // Update the shadow buffer
         uint8_t *srcPtr;
-        ANGLE_VK_TRY(contextVk, sourceBuffer->getBuffer().getDeviceMemory().map(
-                                    contextVk->getDevice(), sourceOffset, size, 0, &srcPtr));
+        ANGLE_TRY(sourceBuffer->getBuffer().mapWithOffset(contextVk, &srcPtr, sourceOffset));
 
         updateShadowBuffer(srcPtr, size, destOffset);
 
         // Unmap the source buffer
-        sourceBuffer->getBuffer().getDeviceMemory().unmap(contextVk->getDevice());
+        sourceBuffer->getBuffer().unmap(contextVk->getRenderer());
     }
 
     vk::CommandBuffer *commandBuffer = nullptr;
@@ -359,9 +358,8 @@ angle::Result BufferVk::mapRangeImpl(ContextVk *contextVk,
             ANGLE_TRY(mBuffer.waitForIdle(contextVk));
         }
 
-        ANGLE_VK_TRY(contextVk,
-                     mBuffer.getDeviceMemory().map(contextVk->getDevice(), offset, length, 0,
-                                                   reinterpret_cast<uint8_t **>(mapPtr)));
+        ANGLE_TRY(mBuffer.mapWithOffset(contextVk, reinterpret_cast<uint8_t **>(mapPtr),
+                                        static_cast<size_t>(offset)));
     }
     else
     {
@@ -394,7 +392,7 @@ angle::Result BufferVk::unmapImpl(ContextVk *contextVk)
 
     if (!mShadowBuffer.valid())
     {
-        mBuffer.getDeviceMemory().unmap(contextVk->getDevice());
+        mBuffer.unmap(contextVk->getRenderer());
         mBuffer.onExternalWrite(VK_ACCESS_HOST_WRITE_BIT);
     }
     else
@@ -450,10 +448,7 @@ angle::Result BufferVk::getIndexRange(const gl::Context *context,
 
         ASSERT(mBuffer.valid());
 
-        const GLuint &typeBytes = gl::GetDrawElementsTypeSize(type);
-
-        ANGLE_VK_TRY(contextVk, mBuffer.getDeviceMemory().map(contextVk->getDevice(), offset,
-                                                              typeBytes * count, 0, &mapPointer));
+        ANGLE_TRY(mBuffer.mapWithOffset(contextVk, &mapPointer, offset));
     }
     else
     {
@@ -462,7 +457,7 @@ angle::Result BufferVk::getIndexRange(const gl::Context *context,
 
     *outRange = gl::ComputeIndexRange(type, mapPointer, count, primitiveRestartEnabled);
 
-    mBuffer.getDeviceMemory().unmap(contextVk->getDevice());
+    mBuffer.unmap(renderer);
     return angle::Result::Continue;
 }
 
@@ -471,15 +466,14 @@ angle::Result BufferVk::directUpdate(ContextVk *contextVk,
                                      size_t size,
                                      size_t offset)
 {
-    VkDevice device     = contextVk->getDevice();
     uint8_t *mapPointer = nullptr;
 
-    ANGLE_VK_TRY(contextVk, mBuffer.getDeviceMemory().map(device, offset, size, 0, &mapPointer));
+    ANGLE_TRY(mBuffer.mapWithOffset(contextVk, &mapPointer, offset));
     ASSERT(mapPointer);
 
     memcpy(mapPointer, data, size);
 
-    mBuffer.getDeviceMemory().unmap(device);
+    mBuffer.unmap(contextVk->getRenderer());
     mBuffer.onExternalWrite(VK_ACCESS_HOST_WRITE_BIT);
 
     return angle::Result::Continue;

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -2132,7 +2132,7 @@ angle::Result ContextVk::drawArraysIndirect(const gl::Context *context,
         // We have instanced vertex attributes that need to be emulated for Vulkan.
         // invalidate any cache and map the buffer so that we can read the indirect data.
         // Mapping the buffer will cause a flush.
-        ANGLE_TRY(currentIndirectBuf->invalidate(this, 0, sizeof(VkDrawIndirectCommand)));
+        ANGLE_TRY(currentIndirectBuf->invalidate(mRenderer, 0, sizeof(VkDrawIndirectCommand)));
         uint8_t *buffPtr;
         ANGLE_TRY(currentIndirectBuf->map(this, &buffPtr));
         const VkDrawIndirectCommand *indirectData =
@@ -2141,7 +2141,7 @@ angle::Result ContextVk::drawArraysIndirect(const gl::Context *context,
         ANGLE_TRY(drawArraysInstanced(context, mode, indirectData->firstVertex,
                                       indirectData->vertexCount, indirectData->instanceCount));
 
-        currentIndirectBuf->unmap(getDevice());
+        currentIndirectBuf->unmap(mRenderer);
         return angle::Result::Continue;
     }
 
@@ -2186,7 +2186,8 @@ angle::Result ContextVk::drawElementsIndirect(const gl::Context *context,
         // We have instanced vertex attributes that need to be emulated for Vulkan.
         // invalidate any cache and map the buffer so that we can read the indirect data.
         // Mapping the buffer will cause a flush.
-        ANGLE_TRY(currentIndirectBuf->invalidate(this, 0, sizeof(VkDrawIndexedIndirectCommand)));
+        ANGLE_TRY(
+            currentIndirectBuf->invalidate(mRenderer, 0, sizeof(VkDrawIndexedIndirectCommand)));
         uint8_t *buffPtr;
         ANGLE_TRY(currentIndirectBuf->map(this, &buffPtr));
         const VkDrawIndexedIndirectCommand *indirectData =
@@ -2195,7 +2196,7 @@ angle::Result ContextVk::drawElementsIndirect(const gl::Context *context,
         ANGLE_TRY(drawElementsInstanced(context, mode, indirectData->indexCount, type, nullptr,
                                         indirectData->instanceCount));
 
-        currentIndirectBuf->unmap(getDevice());
+        currentIndirectBuf->unmap(mRenderer);
         return angle::Result::Continue;
     }
 

src/libANGLE/renderer/vulkan/OverlayVk.cpp

@@ -102,8 +102,8 @@ angle::Result OverlayVk::createFont(ContextVk *contextVk)
 
     mState.initFontData(fontData);
 
-    ANGLE_TRY(fontDataBuffer.get().flush(contextVk, 0, fontDataBuffer.get().getSize()));
-    fontDataBuffer.get().unmap(contextVk->getDevice());
+    ANGLE_TRY(fontDataBuffer.get().flush(renderer, 0, fontDataBuffer.get().getSize()));
+    fontDataBuffer.get().unmap(renderer);
 
     fontDataBuffer.get().onExternalWrite(VK_ACCESS_HOST_WRITE_BIT);
 
@@ -171,8 +171,8 @@ angle::Result OverlayVk::cullWidgets(ContextVk *contextVk)
     gl::Extents presentImageExtents(mPresentImageExtent.width, mPresentImageExtent.height, 1);
     mState.fillEnabledWidgetCoordinates(presentImageExtents, enabledWidgets);
 
-    ANGLE_TRY(enabledWidgetsBuffer.get().flush(contextVk, 0, enabledWidgetsBuffer.get().getSize()));
-    enabledWidgetsBuffer.get().unmap(contextVk->getDevice());
+    ANGLE_TRY(enabledWidgetsBuffer.get().flush(renderer, 0, enabledWidgetsBuffer.get().getSize()));
+    enabledWidgetsBuffer.get().unmap(renderer);
 
     enabledWidgetsBuffer.get().onExternalWrite(VK_ACCESS_HOST_WRITE_BIT);
 
@@ -261,10 +261,10 @@ angle::Result OverlayVk::onPresent(ContextVk *contextVk,
     gl::Extents presentImageExtents(mPresentImageExtent.width, mPresentImageExtent.height, 1);
     mState.fillWidgetData(presentImageExtents, textData, graphData);
 
-    ANGLE_TRY(textDataBuffer.get().flush(contextVk, 0, textDataBuffer.get().getSize()));
-    ANGLE_TRY(graphDataBuffer.get().flush(contextVk, 0, graphDataBuffer.get().getSize()));
-    textDataBuffer.get().unmap(contextVk->getDevice());
-    graphDataBuffer.get().unmap(contextVk->getDevice());
+    ANGLE_TRY(textDataBuffer.get().flush(renderer, 0, textDataBuffer.get().getSize()));
+    ANGLE_TRY(graphDataBuffer.get().flush(renderer, 0, graphDataBuffer.get().getSize()));
+    textDataBuffer.get().unmap(renderer);
+    graphDataBuffer.get().unmap(renderer);
 
     UtilsVk::OverlayDrawParameters params;
     params.subgroupSize[0] = mSubgroupSize[0];

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -31,7 +31,6 @@
 #include "libANGLE/renderer/vulkan/VertexArrayVk.h"
 #include "libANGLE/renderer/vulkan/vk_caps_utils.h"
 #include "libANGLE/renderer/vulkan/vk_format_utils.h"
-#include "libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h"
 #include "libANGLE/trace.h"
 #include "platform/Platform.h"
 
@@ -623,6 +622,8 @@ void RendererVk::onDestroy()
 
     mPipelineCache.destroy(mDevice);
 
+    vma::DestroyAllocator(mAllocator);
+
     if (mGlslangInitialized)
     {
         GlslangRelease();
@@ -925,6 +926,9 @@ angle::Result RendererVk::initialize(DisplayVk *displayVk,
         ANGLE_TRY(initializeDevice(displayVk, firstGraphicsQueueFamily));
     }
 
+    // Create VMA allocator
+    ANGLE_VK_TRY(displayVk, vma::InitAllocator(mPhysicalDevice, mDevice, mInstance, &mAllocator));
+
     // Store the physical device memory properties so we can find the right memory pools.
     mMemoryProperties.init(mPhysicalDevice);
 

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -28,6 +28,7 @@
 #include "libANGLE/renderer/vulkan/vk_format_utils.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 #include "libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h"
+#include "libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h"
 
 namespace egl
 {
@@ -100,6 +101,8 @@ class RendererVk : angle::NonCopyable
     }
     VkDevice getDevice() const { return mDevice; }
 
+    const VmaAllocator &getAllocator() const { return mAllocator; }
+
     angle::Result selectPresentQueueForSurface(DisplayVk *displayVk,
                                                VkSurfaceKHR surface,
                                                uint32_t *presentQueueOut);
@@ -355,6 +358,8 @@ class RendererVk : angle::NonCopyable
 
     // track whether we initialized (or released) glslang
     bool mGlslangInitialized;
+
+    VmaAllocator mAllocator;
 };
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -545,7 +545,7 @@ angle::Result DynamicBuffer::allocate(ContextVk *contextVk,
         if (mBuffer)
         {
             ANGLE_TRY(flush(contextVk));
-            mBuffer->unmap(contextVk->getDevice());
+            mBuffer->unmap(contextVk->getRenderer());
 
             mInFlightBuffers.push_back(mBuffer);
             mBuffer = nullptr;
@@ -617,7 +617,7 @@ angle::Result DynamicBuffer::flush(ContextVk *contextVk)
     if (mHostVisible && (mNextAllocationOffset > mLastFlushOrInvalidateOffset))
     {
         ASSERT(mBuffer != nullptr);
-        ANGLE_TRY(mBuffer->flush(contextVk, mLastFlushOrInvalidateOffset,
+        ANGLE_TRY(mBuffer->flush(contextVk->getRenderer(), mLastFlushOrInvalidateOffset,
                                  mNextAllocationOffset - mLastFlushOrInvalidateOffset));
         mLastFlushOrInvalidateOffset = mNextAllocationOffset;
     }
@@ -629,7 +629,7 @@ angle::Result DynamicBuffer::invalidate(ContextVk *contextVk)
     if (mHostVisible && (mNextAllocationOffset > mLastFlushOrInvalidateOffset))
     {
         ASSERT(mBuffer != nullptr);
-        ANGLE_TRY(mBuffer->invalidate(contextVk, mLastFlushOrInvalidateOffset,
+        ANGLE_TRY(mBuffer->invalidate(contextVk->getRenderer(), mLastFlushOrInvalidateOffset,
                                       mNextAllocationOffset - mLastFlushOrInvalidateOffset));
         mLastFlushOrInvalidateOffset = mNextAllocationOffset;
     }
@@ -700,7 +700,7 @@ void DynamicBuffer::destroy(RendererVk *renderer)
 
     if (mBuffer)
     {
-        mBuffer->unmap(renderer->getDevice());
+        mBuffer->unmap(renderer);
         mBuffer->destroy(renderer);
         delete mBuffer;
         mBuffer = nullptr;
@@ -1689,11 +1689,14 @@ angle::Result BufferHelper::init(ContextVk *contextVk,
         createInfo = &modifiedCreateInfo;
     }
 
-    ANGLE_VK_TRY(contextVk, mBuffer.init(contextVk->getDevice(), *createInfo));
+    VkMemoryPropertyFlags requiredFlags =
+        (memoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+    VkMemoryPropertyFlags preferredFlags =
+        (memoryPropertyFlags & (~VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
+
+    mAllocation.createBufferAndMemory(renderer->getAllocator(), createInfo, requiredFlags,
+                                      preferredFlags, &mBuffer, &mMemoryPropertyFlags);
 
-    VkDeviceSize size;
-    ANGLE_TRY(AllocateBufferMemory(contextVk, memoryPropertyFlags, &mMemoryPropertyFlags, nullptr,
-                                   &mBuffer, &mDeviceMemory, &size));
     mCurrentQueueFamilyIndex = contextVk->getRenderer()->getQueueFamilyIndex();
 
     if (renderer->getFeatures().allocateNonZeroMemory.enabled)
@@ -1701,10 +1704,18 @@ angle::Result BufferHelper::init(ContextVk *contextVk,
         // This memory can't be mapped, so the buffer must be marked as a transfer destination so we
         // can use a staging resource to initialize it to a non-zero value. If the memory is
         // mappable we do the initialization in AllocateBufferMemory.
-        if ((memoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0 &&
+        if ((mMemoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0 &&
             (requestedCreateInfo.usage & VK_BUFFER_USAGE_TRANSFER_DST_BIT) != 0)
         {
-            ANGLE_TRY(initializeNonZeroMemory(contextVk, size));
+            ANGLE_TRY(initializeNonZeroMemory(contextVk, createInfo->size));
+        }
+        else if ((mMemoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
+        {
+            // 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));
         }
     }
 
@@ -1745,23 +1756,22 @@ angle::Result BufferHelper::initializeNonZeroMemory(Context *context, VkDeviceSi
 void BufferHelper::destroy(RendererVk *renderer)
 {
     VkDevice device = renderer->getDevice();
-
-    unmap(device);
+    unmap(renderer);
     mSize       = 0;
     mViewFormat = nullptr;
 
     mBuffer.destroy(device);
     mBufferView.destroy(device);
-    mDeviceMemory.destroy(device);
+    mAllocation.destroy(renderer->getAllocator());
 }
 
 void BufferHelper::release(RendererVk *renderer)
 {
-    unmap(renderer->getDevice());
+    unmap(renderer);
     mSize       = 0;
     mViewFormat = nullptr;
 
-    renderer->collectGarbageAndReinit(&mUse, &mBuffer, &mBufferView, &mDeviceMemory);
+    renderer->collectGarbageAndReinit(&mUse, &mBuffer, &mBufferView, &mAllocation);
 }
 
 bool BufferHelper::needsOnWriteBarrier(VkAccessFlags writeAccessType,
@@ -1821,47 +1831,39 @@ angle::Result BufferHelper::initBufferView(ContextVk *contextVk, const Format &f
 
 angle::Result BufferHelper::mapImpl(ContextVk *contextVk)
 {
-    ANGLE_VK_TRY(contextVk, mDeviceMemory.map(contextVk->getDevice(), 0, mSize, 0, &mMappedMemory));
+    ANGLE_VK_TRY(contextVk,
+                 mAllocation.map(contextVk->getRenderer()->getAllocator(), &mMappedMemory));
+
     return angle::Result::Continue;
 }
 
-void BufferHelper::unmap(VkDevice device)
+void BufferHelper::unmap(RendererVk *renderer)
 {
     if (mMappedMemory)
     {
-        mDeviceMemory.unmap(device);
+        mAllocation.unmap(renderer->getAllocator());
         mMappedMemory = nullptr;
     }
 }
 
-angle::Result BufferHelper::flush(ContextVk *contextVk, VkDeviceSize offset, VkDeviceSize size)
+angle::Result BufferHelper::flush(RendererVk *renderer, VkDeviceSize offset, VkDeviceSize size)
 {
     bool hostVisible  = mMemoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
     bool hostCoherent = mMemoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
     if (hostVisible && !hostCoherent)
     {
-        VkMappedMemoryRange range = {};
-        range.sType               = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
-        range.memory              = mDeviceMemory.getHandle();
-        range.offset              = offset;
-        range.size                = size;
-        ANGLE_VK_TRY(contextVk, vkFlushMappedMemoryRanges(contextVk->getDevice(), 1, &range));
+        mAllocation.flush(renderer->getAllocator(), offset, size);
     }
     return angle::Result::Continue;
 }
 
-angle::Result BufferHelper::invalidate(ContextVk *contextVk, VkDeviceSize offset, VkDeviceSize size)
+angle::Result BufferHelper::invalidate(RendererVk *renderer, VkDeviceSize offset, VkDeviceSize size)
 {
     bool hostVisible  = mMemoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
     bool hostCoherent = mMemoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
     if (hostVisible && !hostCoherent)
     {
-        VkMappedMemoryRange range = {};
-        range.sType               = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
-        range.memory              = mDeviceMemory.getHandle();
-        range.offset              = offset;
-        range.size                = size;
-        ANGLE_VK_TRY(contextVk, vkInvalidateMappedMemoryRanges(contextVk->getDevice(), 1, &range));
+        mAllocation.invalidate(renderer->getAllocator(), offset, size);
     }
     return angle::Result::Continue;
 }

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -553,7 +553,6 @@ class BufferHelper final : public Resource
 
     bool valid() const { return mBuffer.valid(); }
     const Buffer &getBuffer() const { return mBuffer; }
-    const DeviceMemory &getDeviceMemory() const { return mDeviceMemory; }
     VkDeviceSize getSize() const { return mSize; }
     bool isHostVisible() const
     {
@@ -595,13 +594,22 @@ class BufferHelper final : public Resource
         *ptrOut = mMappedMemory;
         return angle::Result::Continue;
     }
-    void unmap(VkDevice device);
+
+    angle::Result mapWithOffset(ContextVk *contextVk, uint8_t **ptrOut, size_t offset)
+    {
+        uint8_t *mapBufPointer;
+        ANGLE_TRY(map(contextVk, &mapBufPointer));
+        *ptrOut = mapBufPointer + offset;
+        return angle::Result::Continue;
+    }
+
+    void unmap(RendererVk *renderer);
 
     // After a sequence of writes, call flush to ensure the data is visible to the device.
-    angle::Result flush(ContextVk *contextVk, VkDeviceSize offset, VkDeviceSize size);
+    angle::Result flush(RendererVk *renderer, VkDeviceSize offset, VkDeviceSize size);
 
     // After a sequence of writes, call invalidate to ensure the data is visible to the host.
-    angle::Result invalidate(ContextVk *contextVk, VkDeviceSize offset, VkDeviceSize size);
+    angle::Result invalidate(RendererVk *renderer, VkDeviceSize offset, VkDeviceSize size);
 
     void changeQueue(uint32_t newQueueFamilyIndex, CommandBuffer *commandBuffer);
 
@@ -641,7 +649,7 @@ class BufferHelper final : public Resource
     // Vulkan objects.
     Buffer mBuffer;
     BufferView mBufferView;
-    DeviceMemory mDeviceMemory;
+    Allocation mAllocation;
 
     // Cached properties.
     VkMemoryPropertyFlags mMemoryPropertyFlags;

src/libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.cpp

@@ -14,30 +14,70 @@
 
 namespace vma
 {
+VkResult InitAllocator(VkPhysicalDevice physicalDevice,
+                       VkDevice device,
+                       VkInstance instance,
+                       VmaAllocator *pAllocator)
+{
+    VmaVulkanFunctions funcs;
+    funcs.vkGetPhysicalDeviceProperties       = vkGetPhysicalDeviceProperties;
+    funcs.vkGetPhysicalDeviceMemoryProperties = vkGetPhysicalDeviceMemoryProperties;
+    funcs.vkAllocateMemory                    = vkAllocateMemory;
+    funcs.vkFreeMemory                        = vkFreeMemory;
+    funcs.vkMapMemory                         = vkMapMemory;
+    funcs.vkUnmapMemory                       = vkUnmapMemory;
+    funcs.vkFlushMappedMemoryRanges           = vkFlushMappedMemoryRanges;
+    funcs.vkInvalidateMappedMemoryRanges      = vkInvalidateMappedMemoryRanges;
+    funcs.vkBindBufferMemory                  = vkBindBufferMemory;
+    funcs.vkBindImageMemory                   = vkBindImageMemory;
+    funcs.vkGetBufferMemoryRequirements       = vkGetBufferMemoryRequirements;
+    funcs.vkGetImageMemoryRequirements        = vkGetImageMemoryRequirements;
+    funcs.vkCreateBuffer                      = vkCreateBuffer;
+    funcs.vkDestroyBuffer                     = vkDestroyBuffer;
+    funcs.vkCreateImage                       = vkCreateImage;
+    funcs.vkDestroyImage                      = vkDestroyImage;
+    funcs.vkCmdCopyBuffer                     = vkCmdCopyBuffer;
+    funcs.vkGetBufferMemoryRequirements2KHR   = vkGetBufferMemoryRequirements2KHR;
+    funcs.vkGetImageMemoryRequirements2KHR    = vkGetImageMemoryRequirements2KHR;
+
+    VmaAllocatorCreateInfo allocatorInfo = {};
+    allocatorInfo.physicalDevice         = physicalDevice;
+    allocatorInfo.device                 = device;
+    allocatorInfo.instance               = instance;
+    allocatorInfo.pVulkanFunctions       = &funcs;
+
+    return vmaCreateAllocator(&allocatorInfo, pAllocator);
+}
+
+void DestroyAllocator(VmaAllocator allocator)
+{
+    vmaDestroyAllocator(allocator);
+}
+
+void FreeMemory(VmaAllocator allocator, VmaAllocation allocation)
+{
+    vmaFreeMemory(allocator, allocation);
+}
+
 VkResult CreateBuffer(VmaAllocator allocator,
                       const VkBufferCreateInfo *pBufferCreateInfo,
                       VkMemoryPropertyFlags requiredFlags,
                       VkMemoryPropertyFlags preferredFlags,
+                      uint32_t *pMemoryTypeIndexOut,
                       VkBuffer *pBuffer,
                       VmaAllocation *pAllocation)
 {
+    VkResult result;
     VmaAllocationCreateInfo allocationCreateInfo = {};
     allocationCreateInfo.requiredFlags           = requiredFlags;
     allocationCreateInfo.preferredFlags          = preferredFlags;
     VmaAllocationInfo allocationInfo             = {};
-    return vmaCreateBuffer(allocator, pBufferCreateInfo, &allocationCreateInfo, pBuffer,
-                           pAllocation, &allocationInfo);
-}
 
-void DestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
-{
-    vmaDestroyBuffer(allocator, buffer, allocation);
-}
+    result = vmaCreateBuffer(allocator, pBufferCreateInfo, &allocationCreateInfo, pBuffer,
+                             pAllocation, &allocationInfo);
+    *pMemoryTypeIndexOut = allocationInfo.memoryType;
 
-void GetMemoryProperties(VmaAllocator allocator,
-                         const VkPhysicalDeviceMemoryProperties **ppPhysicalDeviceMemoryProperties)
-{
-    return vmaGetMemoryProperties(allocator, ppPhysicalDeviceMemoryProperties);
+    return result;
 }
 
 void GetMemoryTypeProperties(VmaAllocator allocator,

src/libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h

@@ -13,27 +13,27 @@
 #include <volk.h>
 
 VK_DEFINE_HANDLE(VmaAllocator)
-VK_DEFINE_HANDLE(VmaPool)
 VK_DEFINE_HANDLE(VmaAllocation)
-VK_DEFINE_HANDLE(VmaDefragmentationContext)
 
 namespace vma
 {
+VkResult InitAllocator(VkPhysicalDevice physicalDevice,
+                       VkDevice device,
+                       VkInstance instance,
+                       VmaAllocator *pAllocator);
 
-// Please add additional functions or parameters here as needed.
+void DestroyAllocator(VmaAllocator allocator);
+
+void FreeMemory(VmaAllocator allocator, VmaAllocation allocation);
 
 VkResult CreateBuffer(VmaAllocator allocator,
                       const VkBufferCreateInfo *pBufferCreateInfo,
                       VkMemoryPropertyFlags requiredFlags,
                       VkMemoryPropertyFlags preferredFlags,
+                      uint32_t *pMemoryTypeIndexOut,
                       VkBuffer *pBuffer,
                       VmaAllocation *pAllocation);
 
-void DestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation);
-
-void GetMemoryProperties(VmaAllocator allocator,
-                         const VkPhysicalDeviceMemoryProperties **ppPhysicalDeviceMemoryProperties);
-
 void GetMemoryTypeProperties(VmaAllocator allocator,
                              uint32_t memoryTypeIndex,
                              VkMemoryPropertyFlags *pFlags);

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -15,6 +15,7 @@
 #include "libANGLE/renderer/vulkan/DisplayVk.h"
 #include "libANGLE/renderer/vulkan/RendererVk.h"
 #include "libANGLE/renderer/vulkan/ResourceVk.h"
+#include "libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h"
 
 namespace angle
 {
@@ -383,10 +384,11 @@ angle::Result MemoryProperties::findCompatibleMemoryIndex(
 // StagingBuffer implementation.
 StagingBuffer::StagingBuffer() : mSize(0) {}
 
-void StagingBuffer::destroy(VkDevice device)
+void StagingBuffer::destroy(RendererVk *renderer)
 {
+    VkDevice device = renderer->getDevice();
     mBuffer.destroy(device);
-    mDeviceMemory.destroy(device);
+    mAllocation.destroy(renderer->getAllocator());
     mSize = 0;
 }
 
@@ -401,14 +403,15 @@ angle::Result StagingBuffer::init(Context *context, VkDeviceSize size, StagingUs
     createInfo.queueFamilyIndexCount = 0;
     createInfo.pQueueFamilyIndices   = nullptr;
 
-    VkMemoryPropertyFlags flags =
-        (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+    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, &mBuffer,
+                                      &memoryPropertyOutFlags);
 
-    ANGLE_VK_TRY(context, mBuffer.init(context->getDevice(), createInfo));
-    VkMemoryPropertyFlags flagsOut = 0;
-    VkDeviceSize sizeIgnored;
-    ANGLE_TRY(AllocateBufferMemory(context, flags, &flagsOut, nullptr, &mBuffer, &mDeviceMemory,
-                                   &sizeIgnored));
     mSize = static_cast<size_t>(size);
     return angle::Result::Continue;
 }
@@ -416,14 +419,14 @@ angle::Result StagingBuffer::init(Context *context, VkDeviceSize size, StagingUs
 void StagingBuffer::release(ContextVk *contextVk)
 {
     contextVk->addGarbage(&mBuffer);
-    contextVk->addGarbage(&mDeviceMemory);
+    contextVk->addGarbage(&mAllocation);
 }
 
 void StagingBuffer::collectGarbage(RendererVk *renderer, Serial serial)
 {
     vk::GarbageList garbageList;
     garbageList.emplace_back(vk::GetGarbage(&mBuffer));
-    garbageList.emplace_back(vk::GetGarbage(&mDeviceMemory));
+    garbageList.emplace_back(vk::GetGarbage(&mAllocation));
 
     vk::SharedResourceUse sharedUse;
     sharedUse.init();
@@ -431,6 +434,26 @@ void StagingBuffer::collectGarbage(RendererVk *renderer, Serial serial)
     renderer->collectGarbage(std::move(sharedUse), std::move(garbageList));
 }
 
+angle::Result InitMappableAllocation(VmaAllocator allocator,
+                                     Allocation *allocation,
+                                     VkDeviceSize size,
+                                     int value,
+                                     VkMemoryPropertyFlags memoryPropertyFlags)
+{
+    uint8_t *mapPointer;
+    allocation->map(allocator, &mapPointer);
+    memset(mapPointer, value, static_cast<size_t>(size));
+
+    if ((memoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0)
+    {
+        allocation->flush(allocator, 0, size);
+    }
+
+    allocation->unmap(allocator);
+
+    return angle::Result::Continue;
+}
+
 angle::Result InitMappableDeviceMemory(Context *context,
                                        DeviceMemory *deviceMemory,
                                        VkDeviceSize size,
@@ -622,6 +645,9 @@ void GarbageObject::destroy(RendererVk *renderer)
         case HandleType::QueryPool:
             vkDestroyQueryPool(device, (VkQueryPool)mHandle, nullptr);
             break;
+        case HandleType::Allocation:
+            vma::FreeMemory(renderer->getAllocator(), (VmaAllocation)mHandle);
+            break;
         default:
             UNREACHABLE();
             break;

src/libANGLE/renderer/vulkan/vk_utils.h

@@ -314,22 +314,26 @@ class StagingBuffer final : angle::NonCopyable
     StagingBuffer();
     void release(ContextVk *contextVk);
     void collectGarbage(RendererVk *renderer, Serial serial);
-    void destroy(VkDevice device);
+    void destroy(RendererVk *renderer);
 
     angle::Result init(Context *context, VkDeviceSize size, StagingUsage usage);
 
     Buffer &getBuffer() { return mBuffer; }
     const Buffer &getBuffer() const { return mBuffer; }
-    DeviceMemory &getDeviceMemory() { return mDeviceMemory; }
-    const DeviceMemory &getDeviceMemory() const { return mDeviceMemory; }
     size_t getSize() const { return mSize; }
 
   private:
     Buffer mBuffer;
-    DeviceMemory mDeviceMemory;
+    Allocation mAllocation;
     size_t mSize;
 };
 
+angle::Result InitMappableAllocation(VmaAllocator allocator,
+                                     Allocation *allcation,
+                                     VkDeviceSize size,
+                                     int value,
+                                     VkMemoryPropertyFlags memoryPropertyFlags);
+
 angle::Result InitMappableDeviceMemory(vk::Context *context,
                                        vk::DeviceMemory *deviceMemory,
                                        VkDeviceSize size,

src/libANGLE/renderer/vulkan/vk_wrapper.h

@@ -14,6 +14,7 @@
 #include "volk.h"
 
 #include "libANGLE/renderer/renderer_utils.h"
+#include "libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h"
 
 namespace rx
 {
@@ -46,7 +47,8 @@ namespace vk
     FUNC(RenderPass)               \
     FUNC(Sampler)                  \
     FUNC(Semaphore)                \
-    FUNC(ShaderModule)
+    FUNC(ShaderModule)             \
+    FUNC(Allocation)
 
 #define ANGLE_COMMA_SEP_FUNC(TYPE) TYPE,
 
@@ -93,6 +95,7 @@ class WrappedObject : angle::NonCopyable
 {
   public:
     HandleT getHandle() const { return mHandle; }
+    void setHandle(HandleT handle) { mHandle = handle; }
     bool valid() const { return (mHandle != VK_NULL_HANDLE); }
 
     const HandleT *ptr() const { return &mHandle; }
@@ -453,6 +456,24 @@ class DeviceMemory final : public WrappedObject<DeviceMemory, VkDeviceMemory>
     void unmap(VkDevice device) 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,
+                                   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);
+};
+
 class RenderPass final : public WrappedObject<RenderPass, VkRenderPass>
 {
   public:
@@ -1294,6 +1315,61 @@ ANGLE_INLINE void DeviceMemory::unmap(VkDevice device) const
     vkUnmapMemory(device, mHandle);
 }
 
+// Allocation implementation.
+ANGLE_INLINE void Allocation::destroy(VmaAllocator allocator)
+{
+    if (valid())
+    {
+        vma::FreeMemory(allocator, mHandle);
+        mHandle = VK_NULL_HANDLE;
+    }
+}
+
+ANGLE_INLINE VkResult Allocation::createBufferAndMemory(VmaAllocator allocator,
+                                                        const VkBufferCreateInfo *pBufferCreateInfo,
+                                                        VkMemoryPropertyFlags requiredFlags,
+                                                        VkMemoryPropertyFlags preferredFlags,
+                                                        Buffer *buffer,
+                                                        VkMemoryPropertyFlags *pMemPropertyOut)
+{
+    ASSERT(!valid());
+    VkResult result;
+    uint32_t memoryTypeIndex;
+    VkBuffer bufferHandle;
+    result = vma::CreateBuffer(allocator, pBufferCreateInfo, requiredFlags, preferredFlags,
+                               &memoryTypeIndex, &bufferHandle, &mHandle);
+    vma::GetMemoryTypeProperties(allocator, memoryTypeIndex, pMemPropertyOut);
+    buffer->setHandle(bufferHandle);
+
+    return result;
+}
+
+ANGLE_INLINE VkResult Allocation::map(VmaAllocator allocator, uint8_t **mapPointer) const
+{
+    ASSERT(valid());
+    return vma::MapMemory(allocator, mHandle, (void **)mapPointer);
+}
+
+ANGLE_INLINE void Allocation::unmap(VmaAllocator allocator) const
+{
+    ASSERT(valid());
+    vma::UnmapMemory(allocator, mHandle);
+}
+
+ANGLE_INLINE void Allocation::flush(VmaAllocator allocator, VkDeviceSize offset, VkDeviceSize size)
+{
+    ASSERT(valid());
+    vma::FlushAllocation(allocator, mHandle, offset, size);
+}
+
+ANGLE_INLINE void Allocation::invalidate(VmaAllocator allocator,
+                                         VkDeviceSize offset,
+                                         VkDeviceSize size)
+{
+    ASSERT(valid());
+    vma::InvalidateAllocation(allocator, mHandle, offset, size);
+}
+
 // RenderPass implementation.
 ANGLE_INLINE void RenderPass::destroy(VkDevice device)
 {