Added function vmaResizeAllocation.

Added tests: function TestResize. Bumped CSV recording file format version to 1.4.

Author: adam-sawicki-a

docs/Recording file format.md

@@ -23,7 +23,7 @@ Formats with only minor version incremented are backward compatible.
 VmaReplay application supports all older versions.
 Current version is:
 
-    1,3
+    1,4
 
 # Configuration
 
@@ -204,6 +204,11 @@ No parameters.
 
 - pool : pointer
 
+**vmaResizeAllocation** (min format version: 1.4)
+
+- allocation : pointer
+- newSize : uint64
+
 # Data types
 
 **bool**
@@ -228,7 +233,7 @@ It should not contain end-of-line characters - results are then undefined.
 # Example file
 
     Vulkan Memory Allocator,Calls recording
-    1,3
+    1,4
     Config,Begin
     PhysicalDevice,apiVersion,4198477
     PhysicalDevice,driverVersion,8388653
@@ -284,4 +289,4 @@ It should not contain end-of-line characters - results are then undefined.
     12552,0.695,0,vmaDestroyImage,000001D85B8B1620
     12552,0.695,0,vmaDestroyBuffer,000001D85B8B16C0
     12552,0.695,0,vmaDestroyBuffer,000001D85B8B1A80
-    12552,0.695,0,vmaDestroyAllocator
+    12552,0.695,0,vmaDestroyAllocator

docs/html/globals.html

@@ -316,7 +316,7 @@ <h3><a id="index_v"></a>- v -</h3><ul>
 : <a class="el" href="vk__mem__alloc_8h.html#ad63b2113c0bfdbeade1cb498f5a8580d">vk_mem_alloc.h</a>
 </li>
 <li>VmaPoolCreateFlagBits
-: <a class="el" href="vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7">vk_mem_alloc.h</a>
+: <a class="el" href="vk__mem__alloc_8h.html#a8f93195158e0e2ac80ca352064e71c1f">vk_mem_alloc.h</a>
 </li>
 <li>VmaPoolCreateFlags
 : <a class="el" href="vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a">vk_mem_alloc.h</a>
@@ -336,6 +336,9 @@ <h3><a id="index_v"></a>- v -</h3><ul>
 <li>VmaRecordSettings
 : <a class="el" href="vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0">vk_mem_alloc.h</a>
 </li>
+<li>vmaResizeAllocation()
+: <a class="el" href="vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696">vk_mem_alloc.h</a>
+</li>
 <li>vmaSetAllocationUserData()
 : <a class="el" href="vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f">vk_mem_alloc.h</a>
 </li>

docs/html/globals_func.html

@@ -163,6 +163,9 @@ <h3><a id="index_v"></a>- v -</h3><ul>
 <li>vmaMapMemory()
 : <a class="el" href="vk__mem__alloc_8h.html#ad5bd1243512d099706de88168992f069">vk_mem_alloc.h</a>
 </li>
+<li>vmaResizeAllocation()
+: <a class="el" href="vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696">vk_mem_alloc.h</a>
+</li>
 <li>vmaSetAllocationUserData()
 : <a class="el" href="vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f">vk_mem_alloc.h</a>
 </li>

docs/html/search/all_10.js

@@ -310,6 +310,9 @@
 <tr class="memitem:a11f0fbc034fa81a4efedd73d61ce7568"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="vk__mem__alloc_8h.html#a11f0fbc034fa81a4efedd73d61ce7568">vmaFreeMemory</a> (<a class="el" href="struct_vma_allocator.html">VmaAllocator</a> allocator, <a class="el" href="struct_vma_allocation.html">VmaAllocation</a> allocation)</td></tr>
 <tr class="memdesc:a11f0fbc034fa81a4efedd73d61ce7568"><td class="mdescLeft">&#160;</td><td class="mdescRight">Frees memory previously allocated using <a class="el" href="vk__mem__alloc_8h.html#abf28077dbf82d0908b8acbe8ee8dd9b8" title="General purpose memory allocation. ">vmaAllocateMemory()</a>, <a class="el" href="vk__mem__alloc_8h.html#a7fdf64415b6c3d83c454f28d2c53df7b">vmaAllocateMemoryForBuffer()</a>, or <a class="el" href="vk__mem__alloc_8h.html#a0faa3f9e5fb233d29d1e00390650febb" title="Function similar to vmaAllocateMemoryForBuffer(). ">vmaAllocateMemoryForImage()</a>.  <a href="#a11f0fbc034fa81a4efedd73d61ce7568">More...</a><br /></td></tr>
 <tr class="separator:a11f0fbc034fa81a4efedd73d61ce7568"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a0ff488958ca72b28e545880463cb8696"><td class="memItemLeft" align="right" valign="top">VkResult&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696">vmaResizeAllocation</a> (<a class="el" href="struct_vma_allocator.html">VmaAllocator</a> allocator, <a class="el" href="struct_vma_allocation.html">VmaAllocation</a> allocation, VkDeviceSize newSize)</td></tr>
+<tr class="memdesc:a0ff488958ca72b28e545880463cb8696"><td class="mdescLeft">&#160;</td><td class="mdescRight">Tries to resize an allocation in place, if there is enough free memory after it.  <a href="#a0ff488958ca72b28e545880463cb8696">More...</a><br /></td></tr>
+<tr class="separator:a0ff488958ca72b28e545880463cb8696"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:a86dd08aba8633bfa4ad0df2e76481d8b"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b">vmaGetAllocationInfo</a> (<a class="el" href="struct_vma_allocator.html">VmaAllocator</a> allocator, <a class="el" href="struct_vma_allocation.html">VmaAllocation</a> allocation, <a class="el" href="struct_vma_allocation_info.html">VmaAllocationInfo</a> *pAllocationInfo)</td></tr>
 <tr class="memdesc:a86dd08aba8633bfa4ad0df2e76481d8b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns current information about specified allocation and atomically marks it as used in current frame.  <a href="#a86dd08aba8633bfa4ad0df2e76481d8b">More...</a><br /></td></tr>
 <tr class="separator:a86dd08aba8633bfa4ad0df2e76481d8b"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -2364,6 +2367,50 @@ <h2 class="memtitle"><span class="permalink"><a href="#ad5bd1243512d099706de8816
 <p>This function fails when used on allocation made in memory type that is not <code>HOST_VISIBLE</code>.</p>
 <p>This function always fails when called for allocation that was created with <a class="el" href="vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a5f436af6c8fe8540573a6d22627a6fd2">VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT</a> flag. Such allocations cannot be mapped. </p>
 
+</div>
+</div>
+<a id="a0ff488958ca72b28e545880463cb8696"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0ff488958ca72b28e545880463cb8696">&#9670;&nbsp;</a></span>vmaResizeAllocation()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">VkResult vmaResizeAllocation </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="struct_vma_allocator.html">VmaAllocator</a>&#160;</td>
+          <td class="paramname"><em>allocator</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype"><a class="el" href="struct_vma_allocation.html">VmaAllocation</a>&#160;</td>
+          <td class="paramname"><em>allocation</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">VkDeviceSize&#160;</td>
+          <td class="paramname"><em>newSize</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Tries to resize an allocation in place, if there is enough free memory after it. </p>
+<p>Tries to change allocation's size without moving or reallocating it. You can both shrink and grow allocation size. When growing, it succeeds only when the allocation belongs to a memory block with enough free space after it.</p>
+<p>Returns <code>VK_SUCCESS</code> if allocation's size has been successfully changed. Returns <code>VK_ERROR_OUT_OF_POOL_MEMORY</code> if allocation's size could not be changed.</p>
+<p>After successful call to this function, <a class="el" href="struct_vma_allocation_info.html#aac76d113a6a5ccbb09fea00fb25fd18f" title="Size of this allocation, in bytes. ">VmaAllocationInfo::size</a> of this allocation changes. All other parameters stay the same: memory pool and type, alignment, offset, mapped pointer.</p>
+<ul>
+<li>Calling this function on allocation that is in lost state fails with result <code>VK_ERROR_VALIDATION_FAILED_EXT</code>.</li>
+<li>Calling this function with <code>newSize</code> same as current allocation size does nothing and returns <code>VK_SUCCESS</code>.</li>
+<li>Resizing dedicated allocations, as well as allocations created in pools that use linear or buddy algorithm, is not supported. The function returns <code>VK_ERROR_FEATURE_NOT_PRESENT</code> in such cases. Support may be added in the future. </li>
+</ul>
+
 </div>
 </div>
 <a id="af9147d31ffc11d62fc187bde283ed14f"></a>

docs/html/search/functions_0.js

@@ -2711,6 +2711,159 @@ static void TestPool_SameSize()
     vmaDestroyPool(g_hAllocator, pool);
 }
 
+static void TestResize()
+{
+    wprintf(L"Testing vmaResizeAllocation...\n");
+
+    const VkDeviceSize KILOBYTE = 1024ull;
+    const VkDeviceSize MEGABYTE = KILOBYTE * 1024;
+
+    VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+    bufCreateInfo.size = 2 * MEGABYTE;
+    bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+    VmaAllocationCreateInfo allocCreateInfo = {};
+    allocCreateInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY;
+    
+    uint32_t memTypeIndex = UINT32_MAX;
+    TEST( vmaFindMemoryTypeIndexForBufferInfo(g_hAllocator, &bufCreateInfo, &allocCreateInfo, &memTypeIndex) == VK_SUCCESS );
+
+    VmaPoolCreateInfo poolCreateInfo = {};
+    poolCreateInfo.flags = VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT;
+    poolCreateInfo.blockSize = 8 * MEGABYTE;
+    poolCreateInfo.minBlockCount = 1;
+    poolCreateInfo.maxBlockCount = 1;
+    poolCreateInfo.memoryTypeIndex = memTypeIndex;
+
+    VmaPool pool;
+    TEST( vmaCreatePool(g_hAllocator, &poolCreateInfo, &pool) == VK_SUCCESS );
+
+    allocCreateInfo.pool = pool;
+
+    // Fill 8 MB pool with 4 * 2 MB allocations.
+    VmaAllocation allocs[4] = {};
+
+    VkMemoryRequirements memReq = {};
+    memReq.memoryTypeBits = UINT32_MAX;
+    memReq.alignment = 4;
+    memReq.size = bufCreateInfo.size;
+
+    VmaAllocationInfo allocInfo = {};
+
+    for(uint32_t i = 0; i < 4; ++i)
+    {
+        TEST( vmaAllocateMemory(g_hAllocator, &memReq, &allocCreateInfo, &allocs[i], nullptr) == VK_SUCCESS );
+    }
+
+    // Now it's: a0 2MB, a1 2MB, a2 2MB, a3 2MB
+
+    // Case: Resize to the same size always succeeds.
+    {
+        TEST( vmaResizeAllocation(g_hAllocator, allocs[0], 2 * MEGABYTE) == VK_SUCCESS);
+        vmaGetAllocationInfo(g_hAllocator, allocs[3], &allocInfo);
+        TEST(allocInfo.size == 2ull * 1024 * 1024);
+    }
+
+    // Case: Shrink allocation at the end.
+    {
+        TEST( vmaResizeAllocation(g_hAllocator, allocs[3], 1 * MEGABYTE) == VK_SUCCESS );
+        vmaGetAllocationInfo(g_hAllocator, allocs[3], &allocInfo);
+        TEST(allocInfo.size == 1ull * 1024 * 1024);
+    }
+    
+    // Now it's: a0 2MB, a1 2MB, a2 2MB, a3 1MB, free 1MB
+
+    // Case: Shrink allocation before free space.
+    {
+        TEST( vmaResizeAllocation(g_hAllocator, allocs[3], 512 * KILOBYTE) == VK_SUCCESS );
+        vmaGetAllocationInfo(g_hAllocator, allocs[3], &allocInfo);
+        TEST(allocInfo.size == 512 * KILOBYTE);
+    }
+
+    // Now it's: a0 2MB, a1 2MB, a2 2MB, a3 0.5MB, free 1.5MB
+
+    // Case: Shrink allocation before next allocation.
+    {
+        TEST( vmaResizeAllocation(g_hAllocator, allocs[0], 1 * MEGABYTE) == VK_SUCCESS );
+        vmaGetAllocationInfo(g_hAllocator, allocs[0], &allocInfo);
+        TEST(allocInfo.size == 1 * MEGABYTE);
+    }
+
+    // Now it's: a0 1MB, free 1 MB, a1 2MB, a2 2MB, a3 0.5MB, free 1.5MB
+
+    // Case: Grow allocation while there is even more space available.
+    {
+        TEST( vmaResizeAllocation(g_hAllocator, allocs[3], 1 * MEGABYTE) == VK_SUCCESS );
+        vmaGetAllocationInfo(g_hAllocator, allocs[3], &allocInfo);
+        TEST(allocInfo.size == 1 * MEGABYTE);
+    }
+
+    // Now it's: a0 1MB, free 1 MB, a1 2MB, a2 2MB, a3 1MB, free 1MB
+
+    // Case: Grow allocation while there is exact amount of free space available.
+    {
+        TEST( vmaResizeAllocation(g_hAllocator, allocs[0], 2 * MEGABYTE) == VK_SUCCESS );
+        vmaGetAllocationInfo(g_hAllocator, allocs[0], &allocInfo);
+        TEST(allocInfo.size == 2 * MEGABYTE);
+    }
+
+    // Now it's: a0 2MB, a1 2MB, a2 2MB, a3 1MB, free 1MB
+
+    // Case: Fail to grow when there is not enough free space due to next allocation.
+    {
+        TEST( vmaResizeAllocation(g_hAllocator, allocs[0], 3 * MEGABYTE) == VK_ERROR_OUT_OF_POOL_MEMORY );
+        vmaGetAllocationInfo(g_hAllocator, allocs[0], &allocInfo);
+        TEST(allocInfo.size == 2 * MEGABYTE);
+    }
+
+    // Case: Fail to grow when there is not enough free space due to end of memory block.
+    {
+        TEST( vmaResizeAllocation(g_hAllocator, allocs[3], 3 * MEGABYTE) == VK_ERROR_OUT_OF_POOL_MEMORY );
+        vmaGetAllocationInfo(g_hAllocator, allocs[3], &allocInfo);
+        TEST(allocInfo.size == 1 * MEGABYTE);
+    }
+
+    for(uint32_t i = 4; i--; )
+    {
+        vmaFreeMemory(g_hAllocator, allocs[i]);
+    }
+
+    vmaDestroyPool(g_hAllocator, pool);
+
+    // Test dedicated allocation
+    {
+        VmaAllocationCreateInfo dedicatedAllocCreateInfo = {};
+        dedicatedAllocCreateInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY;
+        dedicatedAllocCreateInfo.flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
+
+        VmaAllocation dedicatedAlloc = VK_NULL_HANDLE;
+        TEST( vmaAllocateMemory(g_hAllocator, &memReq, &dedicatedAllocCreateInfo, &dedicatedAlloc, nullptr) == VK_SUCCESS );
+
+        // Case: Resize to the same size always succeeds.
+        {
+            TEST( vmaResizeAllocation(g_hAllocator, dedicatedAlloc, 2 * MEGABYTE) == VK_SUCCESS);
+            vmaGetAllocationInfo(g_hAllocator, dedicatedAlloc, &allocInfo);
+            TEST(allocInfo.size == 2ull * 1024 * 1024);
+        }
+
+        // Case: Shrinking fails.
+        {
+            TEST( vmaResizeAllocation(g_hAllocator, dedicatedAlloc, 1 * MEGABYTE) < VK_SUCCESS);
+            vmaGetAllocationInfo(g_hAllocator, dedicatedAlloc, &allocInfo);
+            TEST(allocInfo.size == 2ull * 1024 * 1024);
+        }
+
+        // Case: Growing fails.
+        {
+            TEST( vmaResizeAllocation(g_hAllocator, dedicatedAlloc, 3 * MEGABYTE) < VK_SUCCESS);
+            vmaGetAllocationInfo(g_hAllocator, dedicatedAlloc, &allocInfo);
+            TEST(allocInfo.size == 2ull * 1024 * 1024);
+        }
+
+        vmaFreeMemory(g_hAllocator, dedicatedAlloc);
+    }
+}
+
 static bool ValidatePattern(const void* pMemory, size_t size, uint8_t pattern)
 {
     const uint8_t* pBytes = (const uint8_t*)pMemory;
@@ -4275,7 +4428,7 @@ void Test()
         // ########################################
         // ########################################
 
-        BasicTestBuddyAllocator();
+        TestResize();
         return;
     }
 
@@ -4287,6 +4440,7 @@ void Test()
 #else
     TestPool_SameSize();
     TestHeapSizeLimit();
+    TestResize();
 #endif
 #if VMA_DEBUG_INITIALIZE_ALLOCATIONS
     TestAllocationsInitialization();