<divclass="textblock"><p>Interleaved allocations and deallocations of many objects of varying size can cause fragmentation over time, which can lead to a situation where the library is unable to find a continuous range of free memory for a new allocation despite there is enough free space, just scattered across many small free ranges between existing allocations.</p>
<p>To mitigate this problem, you can use defragmentation feature: structure <aclass="el"href="struct_vma_defragmentation_info2.html"title="Parameters for defragmentation.">VmaDefragmentationInfo2</a>, function <aclass="el"href="vk__mem__alloc_8h.html#a36ba776fd7fd5cb1e9359fdc0d8e6e8a"title="Begins defragmentation process.">vmaDefragmentationBegin()</a>, <aclass="el"href="vk__mem__alloc_8h.html#a8774e20e91e245aae959ba63efa15dd2"title="Ends defragmentation process.">vmaDefragmentationEnd()</a>. Given set of allocations, this function can move them to compact used memory, ensure more continuous free space and possibly also free some <code>VkDeviceMemory</code> blocks.</p>
<li>Updates <aclass="el"href="struct_vma_allocation.html"title="Represents single memory allocation.">VmaAllocation</a> objects to point to new <code>VkDeviceMemory</code> and offset. After allocation has been moved, its <aclass="el"href="struct_vma_allocation_info.html#ae0bfb7dfdf79a76ffefc9a94677a2f67"title="Handle to Vulkan memory object.">VmaAllocationInfo::deviceMemory</a> and/or <aclass="el"href="struct_vma_allocation_info.html#a4a3c732388dbdc7a23f9365b00825268"title="Offset in VkDeviceMemory object to the beginning of this allocation, in bytes. (deviceMemory,...">VmaAllocationInfo::offset</a> changes. You must query them again using <aclass="el"href="vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b"title="Returns current information about specified allocation and atomically marks it as used in current fra...">vmaGetAllocationInfo()</a> if you need them.</li>
<li>Recreate buffers and images that were bound to allocations that were defragmented and bind them with their new places in memory. You must use <code>vkDestroyBuffer()</code>, <code>vkDestroyImage()</code>, <code>vkCreateBuffer()</code>, <code>vkCreateImage()</code>, <aclass="el"href="vk__mem__alloc_8h.html#a6b0929b914b60cf2d45cac4bf3547470"title="Binds buffer to allocation.">vmaBindBufferMemory()</a>, <aclass="el"href="vk__mem__alloc_8h.html#a3d3ca45799923aa5d138e9e5f9eb2da5"title="Binds image to allocation.">vmaBindImageMemory()</a> for that purpose and NOT <aclass="el"href="vk__mem__alloc_8h.html#a0d9f4e4ba5bf9aab1f1c746387753d77"title="Destroys Vulkan buffer and frees allocated memory.">vmaDestroyBuffer()</a>, <aclass="el"href="vk__mem__alloc_8h.html#ae50d2cb3b4a3bfd4dd40987234e50e7e"title="Destroys Vulkan image and frees allocated memory.">vmaDestroyImage()</a>, <aclass="el"href="vk__mem__alloc_8h.html#ac72ee55598617e8eecca384e746bab51">vmaCreateBuffer()</a>, <aclass="el"href="vk__mem__alloc_8h.html#a02a94f25679275851a53e82eacbcfc73"title="Function similar to vmaCreateBuffer().">vmaCreateImage()</a>, because you don't need to destroy or create allocation objects!</li>
<p>Following example demonstrates how you can run defragmentation on CPU. Only allocations created in memory types that are <code>HOST_VISIBLE</code> can be defragmented. Others are ignored.</p>
<divclass="line"><spanclass="comment">// You can make dummy call to vkGetBufferMemoryRequirements here to silence validation layer warning.</span></div>
<divclass="ttc"id="astruct_vma_allocation_info_html"><divclass="ttname"><ahref="struct_vma_allocation_info.html">VmaAllocationInfo</a></div><divclass="ttdoc">Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1357</div></div>
<divclass="ttc"id="astruct_vma_allocator_html"><divclass="ttname"><ahref="struct_vma_allocator.html">VmaAllocator</a></div><divclass="ttdoc">Represents main object of this library initialized.</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_context_html"><divclass="ttname"><ahref="struct_vma_defragmentation_context.html">VmaDefragmentationContext</a></div><divclass="ttdoc">Represents Opaque object that represents started defragmentation process.</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html">VmaDefragmentationInfo2</a></div><divclass="ttdoc">Parameters for defragmentation.</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1763</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html_a3cf86ab32c1da779b4923d301a3056ba"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html#a3cf86ab32c1da779b4923d301a3056ba">VmaDefragmentationInfo2::allocationCount</a></div><divclass="ttdeci">uint32_t allocationCount</div><divclass="ttdoc">Number of allocations in pAllocations array.</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1769</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html_a76d51a644dc7f5405d0cdd0025ecd0cc"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html#a76d51a644dc7f5405d0cdd0025ecd0cc">VmaDefragmentationInfo2::pAllocationsChanged</a></div><divclass="ttdeci">VkBool32 * pAllocationsChanged</div><divclass="ttdoc">Optional, output. Pointer to array that will be filled with information whether the allocation at cer...</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1784</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html_a94c2c7223d52878445a8cccce396b671"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html#a94c2c7223d52878445a8cccce396b671">VmaDefragmentationInfo2::maxCpuAllocationsToMove</a></div><divclass="ttdeci">uint32_t maxCpuAllocationsToMove</div><divclass="ttdoc">Maximum number of allocations that can be moved to a different place using transfers on CPU side,...</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1813</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html_ab6d288f29d028156cf73542d630a2e32"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html#ab6d288f29d028156cf73542d630a2e32">VmaDefragmentationInfo2::pAllocations</a></div><divclass="ttdeci">const VmaAllocation * pAllocations</div><divclass="ttdoc">Pointer to array of allocations that can be defragmented.</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1778</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html_af78e1ea40c22d85137b65f6b384a4d0a"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html#af78e1ea40c22d85137b65f6b384a4d0a">VmaDefragmentationInfo2::maxCpuBytesToMove</a></div><divclass="ttdeci">VkDeviceSize maxCpuBytesToMove</div><divclass="ttdoc">Maximum total numbers of bytes that can be copied while moving allocations to different places using ...</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1808</div></div>
<divclass="ttc"id="avk__mem__alloc_8h_html_a6b0929b914b60cf2d45cac4bf3547470"><divclass="ttname"><ahref="vk__mem__alloc_8h.html#a6b0929b914b60cf2d45cac4bf3547470">vmaBindBufferMemory</a></div><divclass="ttdeci">VkResult vmaBindBufferMemory(VmaAllocator allocator, VmaAllocation allocation, VkBuffer buffer)</div><divclass="ttdoc">Binds buffer to allocation.</div></div>
<divclass="ttc"id="avk__mem__alloc_8h_html_a86dd08aba8633bfa4ad0df2e76481d8b"><divclass="ttname"><ahref="vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b">vmaGetAllocationInfo</a></div><divclass="ttdeci">void vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)</div><divclass="ttdoc">Returns current information about specified allocation and atomically marks it as used in current fra...</div></div>
</div><!-- fragment --><p>Setting <aclass="el"href="struct_vma_defragmentation_info2.html#a76d51a644dc7f5405d0cdd0025ecd0cc"title="Optional, output. Pointer to array that will be filled with information whether the allocation at cer...">VmaDefragmentationInfo2::pAllocationsChanged</a> is optional. This output array tells whether particular allocation in <aclass="el"href="struct_vma_defragmentation_info2.html#ab6d288f29d028156cf73542d630a2e32"title="Pointer to array of allocations that can be defragmented.">VmaDefragmentationInfo2::pAllocations</a> at the same index has been modified during defragmentation. You can pass null, but you then need to query every allocation passed to defragmentation for new parameters using <aclass="el"href="vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b"title="Returns current information about specified allocation and atomically marks it as used in current fra...">vmaGetAllocationInfo()</a> if you might need to recreate and rebind a buffer or image associated with it.</p>
<p>If you use <aclass="el"href="choosing_memory_type.html#choosing_memory_type_custom_memory_pools">Custom memory pools</a>, you can fill <aclass="el"href="struct_vma_defragmentation_info2.html#a7e70aa2a1081d849dcc7829b19d3ec9d"title="Numer of pools in pPools array.">VmaDefragmentationInfo2::poolCount</a> and <aclass="el"href="struct_vma_defragmentation_info2.html#a3c9c6aa5c97d5670f8e362b3a6f3029b"title="Either null or pointer to array of pools to be defragmented.">VmaDefragmentationInfo2::pPools</a> instead of <aclass="el"href="struct_vma_defragmentation_info2.html#a3cf86ab32c1da779b4923d301a3056ba"title="Number of allocations in pAllocations array.">VmaDefragmentationInfo2::allocationCount</a> and <aclass="el"href="struct_vma_defragmentation_info2.html#ab6d288f29d028156cf73542d630a2e32"title="Pointer to array of allocations that can be defragmented.">VmaDefragmentationInfo2::pAllocations</a> to defragment all allocations in given pools. You cannot use <aclass="el"href="struct_vma_defragmentation_info2.html#a76d51a644dc7f5405d0cdd0025ecd0cc"title="Optional, output. Pointer to array that will be filled with information whether the allocation at cer...">VmaDefragmentationInfo2::pAllocationsChanged</a> in that case. You can also combine both methods.</p>
<p>It is also possible to defragment allocations created in memory types that are not <code>HOST_VISIBLE</code>. To do that, you need to pass a command buffer that meets requirements as described in <aclass="el"href="struct_vma_defragmentation_info2.html#a7f71f39590c5316771493d2333f9c1bd"title="Optional. Command buffer where GPU copy commands will be posted.">VmaDefragmentationInfo2::commandBuffer</a>. The way it works is:</p>
<divclass="line">defragInfo.<aclass="code hl_variable"href="struct_vma_defragmentation_info2.html#a4ddbc898d0afe1518f863a3763628f08">maxGpuBytesToMove</a> = VK_WHOLE_SIZE; <spanclass="comment">// Notice it is "GPU" this time.</span></div>
<divclass="line">defragInfo.<aclass="code hl_variable"href="struct_vma_defragmentation_info2.html#a40d53d33e71ba0b66f844ed63c05a3f6">maxGpuAllocationsToMove</a> = UINT32_MAX; <spanclass="comment">// Notice it is "GPU" this time.</span></div>
<divclass="line"><spanclass="comment">// You can make dummy call to vkGetBufferMemoryRequirements here to silence validation layer warning.</span></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html_a40d53d33e71ba0b66f844ed63c05a3f6"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html#a40d53d33e71ba0b66f844ed63c05a3f6">VmaDefragmentationInfo2::maxGpuAllocationsToMove</a></div><divclass="ttdeci">uint32_t maxGpuAllocationsToMove</div><divclass="ttdoc">Maximum number of allocations that can be moved to a different place using transfers on GPU side,...</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1823</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html_a4ddbc898d0afe1518f863a3763628f08"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html#a4ddbc898d0afe1518f863a3763628f08">VmaDefragmentationInfo2::maxGpuBytesToMove</a></div><divclass="ttdeci">VkDeviceSize maxGpuBytesToMove</div><divclass="ttdoc">Maximum total numbers of bytes that can be copied while moving allocations to different places using ...</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1818</div></div>
<divclass="ttc"id="astruct_vma_defragmentation_info2_html_a7f71f39590c5316771493d2333f9c1bd"><divclass="ttname"><ahref="struct_vma_defragmentation_info2.html#a7f71f39590c5316771493d2333f9c1bd">VmaDefragmentationInfo2::commandBuffer</a></div><divclass="ttdeci">VkCommandBuffer commandBuffer</div><divclass="ttdoc">Optional. Command buffer where GPU copy commands will be posted.</div><divclass="ttdef"><b>Definition:</b> vk_mem_alloc.h:1832</div></div>
</div><!-- fragment --><p>You can combine these two methods by specifying non-zero <code>maxGpu*</code> as well as <code>maxCpu*</code> parameters. The library automatically chooses best method to defragment each memory pool.</p>
<p>You may try not to block your entire program to wait until defragmentation finishes, but do it in the background, as long as you carefully fullfill requirements described in function <aclass="el"href="vk__mem__alloc_8h.html#a36ba776fd7fd5cb1e9359fdc0d8e6e8a"title="Begins defragmentation process.">vmaDefragmentationBegin()</a>.</p>
<li>images created with <code>VK_IMAGE_CREATE_ALIAS_BIT</code>, <code>VK_IMAGE_TILING_LINEAR</code>, and being currently in <code>VK_IMAGE_LAYOUT_GENERAL</code> or <code>VK_IMAGE_LAYOUT_PREINITIALIZED</code>.</li>
<p>Defragmentation of images created with <code>VK_IMAGE_TILING_OPTIMAL</code> or in any other layout may give undefined results.</p>
<p>If you defragment allocations bound to images, new images to be bound to new memory region after defragmentation should be created with <code>VK_IMAGE_LAYOUT_PREINITIALIZED</code> and then transitioned to their original layout from before defragmentation if needed using an image memory barrier.</p>
<p>While using defragmentation, you may experience validation layer warnings, which you just need to ignore. See <aclass="el"href="general_considerations.html#general_considerations_validation_layer_warnings">Validation layer warnings</a>.</p>
<p>Please don't expect memory to be fully compacted after defragmentation. Algorithms inside are based on some heuristics that try to maximize number of Vulkan memory blocks to make totally empty to release them, as well as to maximize continuous empty space inside remaining blocks, while minimizing the number and size of allocations that need to be moved. Some fragmentation may still remain - this is normal.</p>
<p>If you want to implement your own, custom defragmentation algorithm, there is infrastructure prepared for that, but it is not exposed through the library API - you need to hack its source code. Here are steps needed to do this:</p>
<li>Main thing you need to do is to define your own class derived from base abstract class <code>VmaDefragmentationAlgorithm</code> and implement your version of its pure virtual methods. See definition and comments of this class for details.</li>
<li>Your code needs to interact with device memory block metadata. If you need more access to its data than it is provided by its public interface, declare your new class as a friend class e.g. in class <code>VmaBlockMetadata_Generic</code>.</li>
<li>If you want to create a flag that would enable your algorithm or pass some additional flags to configure it, add them to <code>VmaDefragmentationFlagBits</code> and use them in <aclass="el"href="struct_vma_defragmentation_info2.html#a53e844ee5633e229cf6daf14b2d9fff9"title="Reserved for future use. Should be 0.">VmaDefragmentationInfo2::flags</a>.</li>
